Developer CD Series 1996 May: Tool Chest/Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso/Tool Chest/Development Tools & Languages/Dylan Related/Mindy/Mindy 1.2 - portable sources/comp/parser.tab.c

Text File | 1995-03-15 | 103.5 KB | 2,685 lines | [TEXT/ttxt]

# line 33 "../../mindy-1.x/comp/parser.y"
#include "../compat/std-c.h"

#include "mindycomp.h"
#include "header.h"
#include "parser.h"
#include "lexer.h"
#include "literal.h"
#include "src.h"
#include "sym.h"

struct token_list {
    int token;
    struct token_list *next;
} *yacc_recovery_list = NULL;

static void yyerror(char *);
static boolean verify_symbol_aux(struct id *id, struct token *against);
static void yacc_recover();
static void push_yacc_recovery(int token);
static void pop_yacc_recoveries(int count);

#define verify_symbol(id,sym) if (verify_symbol_aux(id,sym)) YYERROR


# line 58 "../../mindy-1.x/comp/parser.y"
typedef union  {
    struct _nothing *nothing;
    struct token *token;
    struct body *body;
    struct constituent *constituent;
    struct expr *expr;
    struct bindings *bindings;
    struct param_list *param_list;
    struct param *param;
    struct keyword_param *keyword_param;
    struct id *id;
    struct local_methods *local_methods;
    struct method *method;
    struct binop_series *binop_series;
    struct binop *binop;
    struct literal *literal;
    struct arglist *arglist;
    struct argument *argument;
    struct plist *plist;
    struct return_type_list *return_type_list;
    struct literal_list *literal_list;
    struct block_epilog *block_epilog;
    struct condition_body *condition_body;
    struct incomplete_condition_body *incomplete_condition_body;
    struct condition_clause *condition_clause;
    struct for_header *for_header;
    struct exception_clauses *exception_clauses;
    struct exception_clause *exception_clause;
    struct for_clause *for_clause;
    struct to_part *to_part;
    struct superclass_list *superclass_list;
    struct class_guts *class_guts;
    struct slot_spec *slot_spec;
    struct initarg_spec *initarg_spec;
    boolean bool;
    struct inherited_spec *inherited_spec;
    enum slot_allocation slot_allocation;
    struct gf_suffix *gf_suffix;
    flags_t flags;
    struct else_part *else_part;

    struct defnamespace_constituent *defnamespace_constituent;
    struct variable_names *variable_names;
    struct use_clause *use_clause;
    struct use_options *use_options;
    struct use_option *use_option;
    struct import_option *import_option;
    struct renamings *renamings;
} YYSTYPE;
#ifdef __cplusplus
#  include <stdio.h>
   extern "C" {
     extern void yyerror(char *);
     extern int yylex();
   }
#endif    /* __cplusplus */
# define HEADER_KEY 257
# define HEADER_VAL 258
# define HEADER_END 259
# define BOGUS 260
# define SYMBOL 261
# define KEYWORD 262
# define SYMBOL_LITERAL 263
# define SHARP_T 264
# define SHARP_F 265
# define STRING 266
# define CHARACTER 267
# define INTEGER 268
# define FLOAT 269
# define BINARY_OPERATOR 270
# define LPAREN 271
# define RPAREN 272
# define COMMA 273
# define DOT 274
# define SEMI 275
# define LBRACKET 276
# define RBRACKET 277
# define LBRACE 278
# define RBRACE 279
# define COLON_COLON 280
# define MINUS 281
# define TILDE 282
# define EQUAL 283
# define EQUAL_EQUAL 284
# define ARROW 285
# define SHARP_PAREN 286
# define SHARP_BRACKET 287
# define NEXT 288
# define REST 289
# define KEY 290
# define ALL_KEYS 291
# define ABOVE 292
# define ABSTRACT 293
# define DBEGIN 294
# define BELOW 295
# define BLOCK 296
# define BY 297
# define CASE 298
# define CLASS 299
# define CLEANUP 300
# define CONCRETE 301
# define CONSTANT 302
# define DEFINE 303
# define ELSE 304
# define ELSEIF 305
# define END 306
# define EXCEPTION 307
# define FINALLY 308
# define FOR 309
# define FREE 310
# define FROM 311
# define GENERIC 312
# define HANDLER 313
# define IF 314
# define IN 315
# define INHERITED 316
# define INSTANCE 317
# define KEYED_BY 318
# define KEYWORD_RESERVED_WORD 319
# define LET 320
# define LOCAL 321
# define METHOD 322
# define OPEN 323
# define OTHERWISE 324
# define PRIMARY 325
# define REQUIRED 326
# define SEAL 327
# define SEALED 328
# define SELECT 329
# define SLOT 330
# define SUBCLASS 331
# define THEN 332
# define TO 333
# define UNLESS 334
# define UNTIL 335
# define VARIABLE 336
# define VIRTUAL 337
# define WHILE 338
# define MODULE 339
# define LIBRARY 340
# define EXPORT 341
# define CREATE 342
# define USE 343
# define ALL 344
# define PREFIX_OPTION 345
# define IMPORT_OPTION 346
# define EXCLUDE_OPTION 347
# define EXPORT_OPTION 348
# define RENAME_OPTION 349
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif

/* __YYSCLASS defines the scoping/storage class for global objects
 * that are NOT renamed by the -p option.  By default these names
 * are going to be 'static' so that multi-definition errors
 * will not occur with multiple parsers.
 * If you want (unsupported) access to internal names you need
 * to define this to be null so it implies 'extern' scope.
 * This should not be used in conjunction with -p.
 */
#ifndef __YYSCLASS
# define __YYSCLASS static
#endif
YYSTYPE yylval;
__YYSCLASS YYSTYPE yyval;
typedef int yytabelem;
# define YYERRCODE 256

# line 1175 "../../mindy-1.x/comp/parser.y"


static void yyerror(char *msg)
{
    if (yylval.token)
    error(yylval.token->line, "%s at or before `%s'\n",
          msg, yylval.token->chars);
    else
    error(line_count, "%s at end-of-file\n", msg);
    yacc_recover();
}

static boolean verify_symbol_aux(struct id *id, struct token *token)
{
    if (token) {
    int line = token->line;
    char *ptr = (char *)token->chars;

    if (*ptr == '\\')
        ptr++;

    if (strcasecmp((char *)id->symbol->name, ptr)) {
        error(line, "mismatched name, ``%s'' isn't ``%s''",
          token->chars, id->symbol->name);
        free(token);
        return TRUE;
    }
    else
        free(token);
    }
    return FALSE;
}

static void yacc_recover()
{
    while (yychar) {
    struct token_list *rlist = yacc_recovery_list;
    while (rlist)
        if (rlist->token == yychar)
        return;
        else
        rlist = rlist->next;
    yychar = yylex();
    }
    yyclearin;
}

static void push_yacc_recovery(int token)
{
    struct token_list *newrec;

    newrec = malloc(sizeof(*newrec));
    newrec->token = token;
    newrec->next = yacc_recovery_list;
    yacc_recovery_list = newrec;
}

static void pop_yacc_recoveries(int count)
{
    for ( ; count-- > 0; )
    yacc_recovery_list = yacc_recovery_list->next;
}

struct token *make_token(char *ptr, int len)
{
    struct token *token = malloc(sizeof(struct token)
                 + len + 1 - sizeof(token->chars));

    token->length = len;
    memcpy(token->chars, ptr, len);
    token->line = line_count;
    token->chars[len] = 0;

    return token;
}

__YYSCLASS yytabelem yyexca[] ={
-1, 1,
    0, -1,
    -2, 0,
-1, 59,
    0, 324,
    300, 324,
    304, 324,
    305, 324,
    306, 324,
    307, 324,
    308, 324,
    -2, 0,
-1, 97,
    306, 9,
    -2, 0,
-1, 158,
    272, 237,
    -2, 245,
-1, 234,
    306, 324,
    -2, 0,
-1, 272,
    306, 9,
    -2, 0,
-1, 295,
    306, 9,
    308, 9,
    -2, 0,
-1, 305,
    306, 9,
    -2, 0,
-1, 306,
    306, 9,
    -2, 0,
-1, 332,
    306, 324,
    -2, 0,
-1, 347,
    306, 114,
    -2, 123,
-1, 349,
    306, 324,
    -2, 0,
-1, 363,
    306, 156,
    319, 167,
    -2, 24,
-1, 394,
    306, 117,
    -2, 124,
-1, 476,
    306, 324,
    319, 167,
    -2, 24,
    };
# define YYNPROD 335
# define YYLAST 926
__YYSCLASS yytabelem yyact[]={

    16,   399,   161,   395,   264,   162,   258,   335,   421,   420,
    11,   419,   394,   393,   339,   370,   494,   344,    58,   366,
   311,   164,   150,   313,   165,   126,   289,   247,   317,   191,
   495,   190,    21,   493,    13,    61,    85,   442,   443,   444,
   446,   445,   191,   192,   190,   324,   473,   471,   469,   356,
   466,   352,   357,   521,   484,    17,   515,    73,   483,   353,
    33,    23,    43,    37,    38,    56,    40,    41,    42,    62,
    35,   512,    63,    64,   509,   405,   396,    92,    92,    69,
    29,    30,   424,   138,   138,    44,    45,   401,   402,   175,
   355,   474,   425,    47,   106,    48,   497,    49,   467,   492,
   168,   169,    18,   176,   177,   178,   179,   464,    51,   373,
    23,   461,   455,    50,   416,   139,   139,   415,   414,    19,
    20,    46,   156,   166,   198,   199,   373,    23,    52,   160,
   269,    69,   261,    53,    54,   255,   242,    55,   230,   488,
   209,    68,   228,   148,    24,    25,    26,    27,    28,   457,
   517,   501,   286,   171,   249,    33,   172,    43,    37,    38,
    56,    40,    41,    42,   245,    35,   314,   315,   243,   158,
   159,   244,   239,   240,   340,    29,    30,    23,    92,    92,
    44,    45,   281,    66,   336,   565,   233,   340,    47,    23,
    48,   227,    49,    24,    25,    26,    27,    28,   263,   260,
   223,   564,   337,    51,   548,   544,   342,   232,    50,   138,
    24,    25,    26,    27,    28,   337,    46,    23,   277,   278,
   128,   158,   159,    52,   340,    69,   266,   217,    53,    54,
   224,   218,    55,   272,   287,   291,   553,   168,   429,   275,
   388,   139,   156,   297,   298,   156,   300,   274,   378,   358,
   303,   267,   450,   128,   308,   152,   197,   273,   124,   288,
    24,    25,    26,    27,    28,   547,   152,   535,   330,   290,
   292,   546,    24,    25,    26,    27,    28,   310,    76,   346,
   312,   386,   155,   128,   158,   159,   236,   347,   542,    77,
   333,    78,    79,    22,   128,   314,   315,   350,   235,   329,
    24,    25,    26,    27,    28,   345,   322,   360,   533,   348,
   259,   129,   545,   496,   346,   227,   495,   207,   147,   476,
   349,   215,   374,    80,    81,   332,   531,   262,   529,   377,
   380,    83,   256,   234,    84,   382,    82,   381,   146,   145,
   266,    59,   363,   364,   383,   543,   389,   372,   367,   433,
   291,   385,   384,   406,   407,   375,   409,   410,   411,   412,
   168,   379,   368,   216,   328,   426,   322,   282,   241,   134,
   428,   221,   219,   208,   397,   201,   398,   112,   434,   447,
   448,   413,   408,   107,   290,   113,   146,   452,   431,   453,
   430,   435,   432,   312,   115,   130,   108,   566,   458,   549,
   451,   541,   334,   536,   462,   454,   109,   111,   465,   114,
   449,   365,   110,   327,    23,    43,    37,    38,    56,    40,
    41,    42,   340,   203,   459,   351,   302,   206,   301,   252,
   251,   250,   486,   463,   460,   361,   362,   475,    44,    45,
   238,   237,   229,   214,   485,   210,   200,   144,   143,   489,
   487,   142,   490,   254,   253,    96,   105,   104,   122,   103,
   504,   506,   505,   498,   510,   499,   372,   513,   123,   503,
   502,    69,   102,   101,   100,    98,   522,   491,    86,   568,
   567,    68,   558,   557,   556,   520,   519,    72,   518,   555,
   524,   538,   163,   528,   525,   523,   340,    24,    25,    26,
    27,    28,   530,   187,   188,   376,    69,   458,   283,   259,
   257,   534,   220,   343,   202,   132,   183,   181,   141,   121,
   119,     9,   537,     8,     5,   189,     3,   539,   540,    57,
    10,   137,   125,    67,   170,   167,   550,   157,    95,   551,
   131,    71,   154,   135,    75,   422,   554,   151,    65,   306,
   305,   304,   559,   561,   563,   560,    90,   562,    89,   359,
    88,   295,   294,    99,    60,    17,   284,    97,    32,   569,
    33,    23,    43,    37,    38,    56,    40,    41,    42,     7,
    35,   526,   527,   532,   438,   441,   440,   439,   437,   436,
    29,    30,   321,   323,   316,    44,    45,   341,   194,   193,
   186,   185,   127,    47,    94,    48,    93,    49,   120,   118,
   116,   117,    18,    91,    91,   400,   427,   477,    51,   133,
   423,   418,   417,    50,   307,   195,   196,   140,   354,    19,
    20,    46,   173,   391,   392,   174,   213,    87,    52,    39,
   390,   338,   271,    53,    54,   265,   136,    55,    74,   387,
   184,   552,   248,    36,    24,    25,    26,    27,    28,    33,
    23,    43,    37,    38,    56,    40,    41,    42,    31,    35,
    34,   205,   204,    70,   153,   371,   225,   222,   149,    29,
    30,   112,   369,   309,    44,    45,   182,   479,   180,   113,
   481,    15,    47,    14,    48,   403,    49,   404,   115,   456,
    12,   231,   211,   212,   516,   478,   472,    51,   246,   127,
   470,   111,    50,   114,    91,    91,   110,   468,   514,   480,
    46,   511,   166,   508,   285,   482,   500,    52,     6,     4,
     2,     1,    53,    54,   268,   127,    55,   226,     0,     0,
   270,     0,     0,    24,    25,    26,    27,    28,    33,    23,
    43,    37,    38,    56,    40,    41,    42,   331,    35,   280,
   318,   319,   279,     0,   276,     0,   325,   326,    29,    30,
     0,     0,   293,    44,    45,   174,   296,     0,   299,     0,
     0,    47,   320,    48,     0,    49,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,    51,     0,     0,     0,
     0,    50,     0,     0,     0,     0,     0,     0,     0,    46,
     0,     0,     0,     0,     0,     0,    52,     0,     0,     0,
     0,    53,    54,     0,     0,    55,     0,     0,     0,     0,
     0,     0,    24,    25,    26,    27,    28,   507,    23,    43,
    37,    38,    56,    40,    41,    42,     0,    35,     0,     0,
     0,     0,     0,     0,     0,     0,     0,    29,    30,     0,
     0,     0,    44,    45,     0,     0,     0,     0,     0,     0,
    47,     0,    48,     0,    49,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,    51,     0,     0,     0,     0,
    50,     0,     0,     0,     0,     0,     0,     0,    46,     0,
     0,     0,     0,     0,     0,    52,     0,     0,     0,     0,
    53,    54,     0,     0,    55,     0,     0,     0,     0,     0,
     0,    24,    25,    26,    27,    28 };
__YYSCLASS yytabelem yypact[]={

   267, -3000, -3000, -3000,   264,   272, -3000,   309, -3000,   271,
 -3000, -3000,    66, -3000, -3000, -3000, -3000, -3000,  -267,  -130,
  -265, -3000,     8, -3000, -3000, -3000, -3000, -3000, -3000,  -106,
  -106,    60, -3000, -3000, -3000,   487, -3000, -3000, -3000,   212,
 -3000, -3000, -3000, -3000,   152,   152,   184, -3000,   204, -3000,
   203,   202,   201,   188,   186,   185, -3000, -3000, -3000,   309,
    84,   210,   210,   259,   258, -3000,   197,   -25,   -36,    31,
   122, -3000,   254, -3000,     8,  -106, -3000, -3000, -3000, -3000,
 -3000, -3000,   487,   487,   257,   179, -3000,   176,   175,    65,
 -3000, -3000, -3000,    41,   113,  -163,    -6,   309,   231,   398,
   487,  -182,   487,   487,   487,   487, -3000,   256,   255,   254,
 -3000, -3000, -3000, -3000, -3000, -3000, -3000, -3000, -3000,  -299,
 -3000,  -312,   -27,   487,   487,   174, -3000,   102,   253,  -106,
  -265, -3000,   184,  -106, -3000,    40,   100, -3000, -3000,   487,
   173, -3000, -3000, -3000, -3000,   152,   152, -3000,  -265,   171,
    90, -3000,   -53,    99, -3000,   251,    98, -3000,   -73, -3000,
  -164, -3000,   170, -3000,  -168, -3000,   -78,    58,    13,   169,
   168,   487,   487,    95,  -147,   -36,  -143,   159,   158,   157,
 -3000,   183, -3000,   182, -3000,  -171,    57, -3000, -3000, -3000,
   249,   248,   248,  -174,    52, -3000, -3000,   487,    67, -3000,
   -32,   -36, -3000, -3000, -3000,  -176, -3000, -3000,   487, -3000,
 -3000, -3000, -3000, -3000,   -28, -3000,    -6,   487,   487,   -69,
 -3000,  -121, -3000,  -109, -3000,    94,   247, -3000, -3000, -3000,
  -146,   309, -3000, -3000,  -201,   309,   487, -3000, -3000, -3000,
 -3000,  -182,   487,   487,   245,   487,   156,   154, -3000,   487,
 -3000, -3000, -3000,   487,     5,  -311,  -299, -3000,    93, -3000,
    93,  -295,  -312, -3000,   141,    91,   -45,   487, -3000,  -265,
 -3000,    50,   309,   -87, -3000,    90, -3000, -3000, -3000, -3000,
 -3000, -3000,   -85,    34,   309, -3000, -3000, -3000, -3000, -3000,
    45,    13, -3000, -3000,   309,   309, -3000,  -281, -3000,  -256,
  -243,   -34, -3000, -3000,   309,   309,   309,    70, -3000,   139,
    75, -3000,    89, -3000,  -135, -3000,   231, -3000, -3000, -3000,
 -3000,    82,   244,   231, -3000, -3000, -3000,   -35,   -45,   487,
 -3000,   231,   309, -3000, -3000, -3000,   -74,   235,    78, -3000,
     1, -3000, -3000, -3000,   -43,   487,  -106,  -231, -3000,  -201,
  -217,  -233,   487,   487,  -143,   487,   487,   487,   487,   398,
  -188,  -189,  -192,  -234,   487,   -47, -3000,     5,  -124, -3000,
 -3000,    76,   231,    -1, -3000,  -308, -3000, -3000,   487,   487,
 -3000, -3000, -3000,   138, -3000,   -37,   487, -3000,   487,   133,
 -3000,  -194, -3000,  -151,  -231, -3000,   163, -3000, -3000,  -195,
 -3000,   309,   162,  -199, -3000,   309, -3000, -3000, -3000, -3000,
 -3000, -3000,  -282,  -208,  -286,  -288,  -292,  -215,    44, -3000,
 -3000, -3000,   388,  -261,  -276, -3000, -3000, -3000, -3000,   161,
    75, -3000, -3000,  -152,    -1, -3000, -3000, -3000, -3000, -3000,
 -3000, -3000,   211,  -245,    38,    35,  -248, -3000, -3000, -3000,
   235, -3000, -3000, -3000, -3000,  -145,  -231,   309, -3000,   309,
   576,  -240, -3000,   487,  -238, -3000,   487,  -273, -3000, -3000,
 -3000, -3000, -3000, -3000,  -149, -3000,  -234,  -277, -3000, -3000,
 -3000, -3000, -3000,   214,   234,    67,   -74, -3000, -3000, -3000,
 -3000, -3000, -3000,   232, -3000,    49,    47, -3000, -3000, -3000,
 -3000, -3000, -3000,  -231, -3000, -3000,    67,   -13, -3000, -3000,
   131, -3000, -3000, -3000, -3000, -3000,   231, -3000, -3000, -3000,
 -3000,   230,    67,    67, -3000,   129,     9,    72,   -80, -3000,
    33, -3000,    -8,   -81,   127,   487,   309, -3000,   -44, -3000,
 -3000,    67, -3000,   228,   223, -3000, -3000,   222,   221,   309,
    67,  -217,    67,   487, -3000,   -84, -3000,  -100, -3000, -3000,
   125, -3000, -3000, -3000,   219,   218,   309, -3000, -3000, -3000 };
__YYSCLASS yytabelem yypgo[]={

     0,    32,   737,   731,   730,   729,   728,   726,   724,   723,
   721,   718,   717,   710,   706,   704,   487,    18,   701,     5,
     2,   129,   700,   699,   697,   695,    34,   693,   691,   688,
   686,   548,   532,   683,    19,    20,    23,   682,    15,   678,
   321,   547,   542,   537,   677,   230,   533,    22,   676,   675,
   674,    25,   673,   541,   670,   540,   538,     0,   293,   668,
   653,   652,    27,   651,    14,    17,   649,   648,   544,   543,
   646,   531,     4,   645,   642,     7,   641,   568,   639,   556,
   637,   560,   558,   634,   633,    21,    24,   534,    13,    12,
     3,    26,   535,   632,   628,   624,   622,   621,    11,     9,
   620,     8,   617,   616,   545,   615,     1,   609,   608,   601,
   600,   599,   598,   594,   593,   504,   525,   503,   592,   589,
   588,   587,   586,   585,   584,   583,   582,   581,    16,     6,
   579,   567,   566,   563,   562,   561,   559,   551,   550,   549 };
__YYSCLASS yytabelem yyr1[]={

     0,     3,     4,     4,     5,     5,   130,     6,    20,    21,
    21,    22,    22,    26,    26,    26,    26,    27,    27,    27,
    27,    27,    27,    27,   104,   104,   104,   104,   104,   104,
   104,    28,    28,    28,    28,    31,    31,    32,    32,    32,
    46,    46,    52,    52,    53,     1,     1,     1,     1,     1,
     1,    57,    57,    57,    67,    67,    68,    68,    68,    68,
    58,    58,    58,    59,    59,    59,    59,    59,    59,    59,
    59,    69,    69,    70,    70,    71,    71,    77,    77,    77,
    77,    77,    77,    77,    77,    77,    77,    78,    78,    80,
    81,    81,    82,    82,    79,    79,   131,    60,   132,    60,
   133,    60,   134,    60,   135,    60,   136,    60,   137,    60,
   138,    60,   139,    60,    84,    84,    83,    83,    85,    87,
    87,    87,    87,    88,    88,    89,    89,    90,    90,    90,
    86,    86,    86,    86,    91,    91,    91,    92,    92,    93,
    93,    93,    93,    93,    61,    23,    24,   105,   105,    94,
    94,    94,    94,    29,    95,    95,    96,    96,    97,    97,
    97,    97,    97,    97,    98,    99,   100,   100,   101,   102,
   102,   102,   102,   102,   102,    63,    63,    72,    72,    73,
    73,    30,   103,   103,   103,    33,    33,    33,    34,    34,
    34,    35,    35,    35,    36,    36,    37,    37,    38,    38,
    38,    49,    49,    54,    55,    56,    56,    56,    74,    74,
    75,    75,    75,    75,    76,    76,    64,    64,    39,    39,
    39,    40,    40,    40,    47,    47,    47,    41,    41,    41,
    50,    42,    42,    42,    51,    43,    43,    44,    44,    44,
    45,    45,    45,    48,    48,     2,     2,    65,    65,    66,
    66,   107,   113,   113,   109,   109,   109,   110,   110,   110,
   110,   110,   110,   115,   116,   117,   118,   118,   119,   119,
   119,   119,   119,   120,   124,   124,   127,   127,   126,   126,
   126,   126,   121,   123,   123,   122,   122,   125,   125,   128,
   128,   129,   129,   108,   114,   114,   111,   111,   111,   112,
   112,   112,   112,     7,     7,     8,     8,     9,     9,    10,
    10,    11,    11,    12,    12,    13,    13,    14,    14,    15,
    15,    16,    16,    17,    17,    18,    18,    19,    19,    62,
    62,   106,   106,    25,    25 };
__YYSCLASS yytabelem yyr2[]={

     0,     4,     3,     5,     5,     7,     1,     5,     5,     1,
     3,     3,     7,     3,     3,     3,     3,     9,     7,     9,
     9,     7,     7,     7,     1,     5,     5,     5,     5,     5,
     5,     5,    11,    17,     5,     7,    11,     3,     3,     7,
     3,     7,     3,     7,     5,     2,     2,     2,     2,     2,
     2,     3,     3,     5,     5,     7,     3,     3,     3,     3,
     5,     5,     3,     3,     3,     9,     9,     3,     7,     7,
     3,     1,     3,     3,     7,     3,     5,     3,     3,     3,
     3,     3,     3,     3,     7,     7,     7,     3,     5,     7,
     1,     3,     3,     7,     3,     3,     1,     9,     1,    19,
     1,    11,     1,    19,     1,    19,     1,    19,     1,    17,
     1,    17,     1,    17,     1,     3,     7,     3,     3,     5,
     5,     3,     7,     1,     3,     3,     5,     7,    13,    17,
     7,     5,     7,     7,     5,     7,     7,     7,     7,    11,
    15,     7,    11,    11,     5,     5,     5,     5,    13,     1,
     5,     5,     5,    17,     3,     7,     1,     5,     3,     3,
     3,     7,     7,     7,    13,     9,     3,     1,     9,     1,
     3,     3,     3,     3,     3,     1,     5,     1,     3,     7,
     9,    11,     3,     7,    11,     1,     5,     3,     1,     7,
     5,     3,     7,     3,     5,     3,     1,     3,     3,     7,
     7,     7,     5,     9,    11,    13,    11,    11,     5,     9,
     1,     5,     3,     9,     3,     7,     3,     7,     1,     5,
     3,     1,     7,     5,     3,     7,     7,     3,     7,     3,
     5,     3,     7,     3,     5,     5,     3,     1,     5,     3,
     3,     7,     7,     9,    11,     1,     3,     1,     5,     1,
     5,    11,     1,     3,     1,     2,     5,     3,     3,     3,
     7,     7,     7,     5,     5,     7,     1,     7,     2,     2,
     2,     2,     2,     5,     5,     9,     1,     3,     3,     7,
     7,    11,     5,     5,     5,     7,     9,     7,    11,     5,
     7,     3,     7,    11,     1,     3,     1,     2,     5,     3,
     3,     7,     7,     1,     3,     1,     3,     1,     3,     1,
     3,     1,     3,     1,     3,     1,     3,     1,     3,     1,
     3,     1,     3,     1,     3,     1,     3,     1,     3,     1,
     3,     1,     3,     1,     3 };
__YYSCLASS yytabelem yychk[]={

 -3000,    -3,    -4,   259,    -5,   257,    -6,  -130,   259,   257,
   258,   -20,   -22,   -26,   -27,   -28,   -57,   256,   303,   320,
   321,    -1,   -58,   262,   345,   346,   347,   348,   349,   281,
   282,   -59,   -77,   261,   -54,   271,   -60,   264,   265,   -78,
   267,   268,   269,   263,   286,   287,   322,   294,   296,   298,
   314,   309,   329,   334,   335,   338,   266,   258,   -17,   275,
  -104,   302,   336,   339,   340,   -31,   313,   -46,   271,   261,
   -52,   -53,   -16,   322,   -67,   -68,   270,   281,   283,   284,
   -58,   -58,   276,   271,   274,   -57,   266,   -80,   -81,   -82,
   -79,   -77,    -1,   -81,   -82,   -56,   271,  -131,   271,  -133,
   271,   271,   271,   271,   271,   271,   -26,   299,   312,   322,
   328,   323,   293,   301,   325,   310,   -31,   -31,  -107,   261,
  -108,   261,   261,   271,   283,   -32,   -51,   -46,   289,   280,
   273,   -55,   261,   -68,   -58,   -69,   -70,   -71,   -57,    -1,
   -69,   261,   272,   272,   272,   274,   273,   277,   306,   -39,
   -47,   -41,   261,   -50,   -42,   288,   -51,   -43,   290,   291,
   -21,   -20,   -19,   261,   -85,   -86,   324,   -92,   -57,   -57,
   -87,   335,   338,   -93,   -46,   271,   -57,   -57,   -57,   -57,
   -29,   261,   -30,   261,   -55,  -109,  -110,  -117,  -115,  -116,
   343,   341,   342,  -111,  -112,  -117,  -115,   283,   -57,   -57,
   272,   273,   261,   -58,   -53,   -56,   -58,   277,   273,   -57,
   272,   -79,   -79,   -16,   272,   -40,   273,   280,   284,   273,
   261,   273,   -44,   273,   -45,   -48,    -2,    -1,   306,   272,
   306,   -18,   285,   -17,   275,   285,   273,   272,   272,   -57,
   -57,   273,   283,   315,   318,   311,   -32,   -62,   -61,   297,
   272,   272,   272,   271,   271,   306,   275,   261,  -129,   261,
  -129,   306,   275,   -57,   -72,   -73,   273,   283,   -32,   306,
   -71,   -74,   -17,   285,   275,   -47,   -41,   -57,   -57,   -42,
   -43,   291,   273,   261,  -132,    -8,   298,   -20,   -86,   -91,
   -26,   -57,   -26,   -92,  -134,  -135,   -87,   -57,   -57,   -46,
   -57,   272,   272,   -57,  -137,  -138,  -139,   -95,   -57,   -33,
   -47,   -35,   -51,   -36,   290,   291,  -113,   339,  -117,  -115,
  -116,  -118,   273,  -114,   340,  -117,  -115,   272,   273,    -1,
   -57,   -16,   275,   -17,   -21,   -75,   271,   289,   -76,   -64,
   261,   -40,   291,   -45,   -65,   271,   280,   -20,   -17,   275,
   -20,   -21,   332,   315,   -94,   333,   292,   295,   283,  -136,
   -20,   -21,   -21,   272,   273,   272,   -34,   273,   273,   -37,
   -38,   -49,    -1,   261,   -19,   273,   261,   -19,   283,    -1,
   -57,   -19,   -20,   -75,   -64,   273,   280,   -66,   283,   -57,
   -58,   -84,   -83,   -88,   -89,   -90,   307,   -86,   -91,  -106,
  -105,   304,   305,   -25,   -24,   308,   -57,   -57,   -62,   -57,
   -57,   -57,   -57,   -85,   306,   306,   306,   -96,   -97,   -98,
   -99,  -101,  -104,  -100,   316,   326,   -57,  -103,   -72,   285,
   -47,   -35,   -36,   273,   -19,   -65,  -119,  -120,  -124,  -121,
  -122,  -123,   345,   346,   347,   349,   348,   -57,   -57,   272,
   289,   -64,   -57,   -57,   272,   306,   -23,   300,   -90,   261,
   271,   306,   -20,   271,   306,   -20,   332,   306,   -12,   334,
   -13,   335,   -14,   338,   306,   -17,   275,  -102,   317,   299,
   331,   302,   337,   319,   330,   -64,   271,   -34,   291,   -38,
   -65,   266,   344,   278,  -128,   278,   278,   344,  -128,   -64,
    -7,   296,   -88,   -89,   -20,   -20,   -57,   261,    -9,   314,
   -57,   -10,   309,   -57,   -11,   329,   -15,   299,   -98,   -99,
  -101,   330,   262,   261,   -72,   -75,  -127,  -126,   261,   279,
  -129,   279,  -125,   261,   -72,   280,   272,   -19,   261,   -72,
   -72,   272,   279,   273,   285,   279,   279,   273,   285,   272,
   -57,   -20,   -63,   280,   -72,   261,   261,   261,   261,   -20,
   -72,  -106,   -72,   -57,   285,   285,   272,   261,   261,   -20 };
__YYSCLASS yytabelem yydef[]={

     0,    -2,     6,     2,     0,     0,     1,     0,     3,     0,
     4,     7,   323,    11,    13,    14,    15,    16,    24,     0,
   321,    51,    52,    45,    46,    47,    48,    49,    50,     0,
     0,    62,    63,    64,    67,     0,    70,    77,    78,    79,
    80,    81,    82,    83,    90,    90,     0,    96,     0,   100,
     0,     0,     0,     0,     0,     0,    87,     5,     8,    -2,
     0,     0,     0,     0,     0,    31,     0,     0,     0,    40,
    34,    42,     0,   322,    53,     0,    56,    57,    58,    59,
    60,    61,    71,    71,     0,     0,    88,     0,     0,    91,
    92,    94,    95,     0,    91,     0,   218,    -2,   327,     0,
     0,     0,     0,     0,     0,     0,    12,     0,     0,     0,
    25,    26,    27,    28,    29,    30,    18,    21,    22,   254,
    23,   296,     0,     0,     0,     0,    37,    38,     0,     0,
   321,    44,     0,     0,    54,     0,    72,    73,    75,    51,
     0,    68,    69,    84,    85,     0,     0,    86,   321,     0,
   221,   220,   224,   227,   229,     0,   231,   233,    -2,   236,
     0,    10,     0,   328,     0,   118,   325,   323,     0,     0,
     0,     0,     0,   121,     0,     0,   329,     0,     0,     0,
    17,     0,    19,     0,    20,     0,   255,   257,   258,   259,
     0,     0,     0,     0,   297,   299,   300,     0,   177,    35,
     0,     0,   234,    41,    43,     0,    55,    65,     0,    76,
    66,    89,    93,   203,   323,   219,     0,     0,     0,     0,
   230,     0,   235,     0,   239,   240,     0,   246,    97,    98,
   305,     0,   326,   131,    -2,     0,     0,   102,   104,   119,
   120,     0,     0,     0,     0,     0,     0,     0,   330,     0,
   108,   110,   112,     0,   185,   252,   256,   266,   263,   291,
   264,   294,   298,    32,     0,   178,     0,     0,    39,   321,
    74,   323,    -2,   210,   324,   221,   223,   225,   226,   228,
   232,   238,   245,   247,     0,   101,   306,   130,   132,   133,
   323,    15,   137,   138,     0,    -2,   122,     0,   141,     0,
   149,     0,   106,   144,     0,    -2,    -2,     0,   154,     0,
   188,   187,   191,   193,   196,   195,   327,   253,   260,   261,
   262,   265,     0,   327,   295,   301,   302,     0,     0,     0,
    36,   327,    -2,   206,   207,   208,   210,     0,   212,   214,
   216,   222,   241,   242,   249,     0,     0,    -2,   134,    -2,
   331,   333,     0,     0,   329,     0,     0,     0,     0,     0,
     0,     0,     0,    -2,     0,   177,   186,     0,     0,   194,
   197,   198,   327,   247,   251,     0,   292,   293,     0,     0,
   179,   204,   205,     0,   211,     0,     0,   243,     0,     0,
   248,     0,   115,     0,    -2,   125,     0,   135,   136,     0,
   332,     0,     0,     0,   334,     0,   139,   142,   143,   150,
   151,   152,     0,     0,   313,   315,   317,     0,   323,   158,
   159,   160,   169,     0,     0,   166,   155,   181,   182,     0,
   188,   190,   192,     0,   247,   202,   267,   268,   269,   270,
   271,   272,     0,     0,     0,     0,     0,    33,   180,   209,
     0,   215,   217,   250,   244,   303,   123,     0,   126,     0,
     0,   307,   147,     0,   309,   146,     0,   311,   109,   314,
   111,   316,   113,   318,   319,   157,    -2,     0,   170,   171,
   172,   173,   174,     0,     0,   177,   210,   189,   199,   200,
   201,   273,   274,   276,   282,     0,     0,   283,   284,   213,
    99,   304,   116,   124,   145,   127,   177,    64,   103,   308,
     0,   105,   310,   140,   107,   312,   327,   320,   161,   162,
   163,     0,   177,   177,   183,     0,     0,   277,   278,   289,
     0,   285,     0,     0,     0,     0,     0,   153,   175,   165,
   168,   177,   275,     0,     0,   290,   286,     0,     0,     0,
   177,   331,   177,     0,   184,   280,   279,     0,   287,   128,
     0,   148,   164,   176,     0,     0,     0,   281,   288,   129 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#    define YYDEBUG    0    /* don't allow debugging */
#endif

#if YYDEBUG

__YYSCLASS yytoktype yytoks[] =
{
    "HEADER_KEY",    257,
    "HEADER_VAL",    258,
    "HEADER_END",    259,
    "BOGUS",    260,
    "SYMBOL",    261,
    "KEYWORD",    262,
    "SYMBOL_LITERAL",    263,
    "SHARP_T",    264,
    "SHARP_F",    265,
    "STRING",    266,
    "CHARACTER",    267,
    "INTEGER",    268,
    "FLOAT",    269,
    "BINARY_OPERATOR",    270,
    "LPAREN",    271,
    "RPAREN",    272,
    "COMMA",    273,
    "DOT",    274,
    "SEMI",    275,
    "LBRACKET",    276,
    "RBRACKET",    277,
    "LBRACE",    278,
    "RBRACE",    279,
    "COLON_COLON",    280,
    "MINUS",    281,
    "TILDE",    282,
    "EQUAL",    283,
    "EQUAL_EQUAL",    284,
    "ARROW",    285,
    "SHARP_PAREN",    286,
    "SHARP_BRACKET",    287,
    "NEXT",    288,
    "REST",    289,
    "KEY",    290,
    "ALL_KEYS",    291,
    "ABOVE",    292,
    "ABSTRACT",    293,
    "DBEGIN",    294,
    "BELOW",    295,
    "BLOCK",    296,
    "BY",    297,
    "CASE",    298,
    "CLASS",    299,
    "CLEANUP",    300,
    "CONCRETE",    301,
    "CONSTANT",    302,
    "DEFINE",    303,
    "ELSE",    304,
    "ELSEIF",    305,
    "END",    306,
    "EXCEPTION",    307,
    "FINALLY",    308,
    "FOR",    309,
    "FREE",    310,
    "FROM",    311,
    "GENERIC",    312,
    "HANDLER",    313,
    "IF",    314,
    "IN",    315,
    "INHERITED",    316,
    "INSTANCE",    317,
    "KEYED_BY",    318,
    "KEYWORD_RESERVED_WORD",    319,
    "LET",    320,
    "LOCAL",    321,
    "METHOD",    322,
    "OPEN",    323,
    "OTHERWISE",    324,
    "PRIMARY",    325,
    "REQUIRED",    326,
    "SEAL",    327,
    "SEALED",    328,
    "SELECT",    329,
    "SLOT",    330,
    "SUBCLASS",    331,
    "THEN",    332,
    "TO",    333,
    "UNLESS",    334,
    "UNTIL",    335,
    "VARIABLE",    336,
    "VIRTUAL",    337,
    "WHILE",    338,
    "MODULE",    339,
    "LIBRARY",    340,
    "EXPORT",    341,
    "CREATE",    342,
    "USE",    343,
    "ALL",    344,
    "PREFIX_OPTION",    345,
    "IMPORT_OPTION",    346,
    "EXCLUDE_OPTION",    347,
    "EXPORT_OPTION",    348,
    "RENAME_OPTION",    349,
    "-unknown-",    -1    /* ends search */
};

__YYSCLASS char * yyreds[] =
{
    "-no such reduction-",
    "dylan_file : dylan_headers dylan_program",
    "dylan_headers : HEADER_END",
    "dylan_headers : header_list HEADER_END",
    "header_list : HEADER_KEY HEADER_VAL",
    "header_list : header_list HEADER_KEY HEADER_VAL",
    "dylan_program : /* empty */",
    "dylan_program : body",
    "body : constituents semi_opt",
    "body_opt : /* empty */",
    "body_opt : body",
    "constituents : constituent",
    "constituents : constituents SEMI constituent",
    "constituent : defining_form",
    "constituent : local_declaration",
    "constituent : expression",
    "constituent : error",
    "defining_form : DEFINE flags CLASS class_definition",
    "defining_form : DEFINE CONSTANT bindings",
    "defining_form : DEFINE flags GENERIC generic_function_definition",
    "defining_form : DEFINE flags METHOD named_method",
    "defining_form : DEFINE VARIABLE bindings",
    "defining_form : DEFINE MODULE module_definition",
    "defining_form : DEFINE LIBRARY library_definition",
    "flags : /* empty */",
    "flags : flags SEALED",
    "flags : flags OPEN",
    "flags : flags ABSTRACT",
    "flags : flags CONCRETE",
    "flags : flags PRIMARY",
    "flags : flags FREE",
    "local_declaration : LET bindings",
    "local_declaration : LET HANDLER SYMBOL EQUAL expression",
    "local_declaration : LET HANDLER LPAREN expression property_list_opt RPAREN EQUAL expression",
    "local_declaration : LOCAL local_methods",
    "bindings : variable EQUAL expression",
    "bindings : LPAREN variables RPAREN EQUAL expression",
    "variables : rest_parameter",
    "variables : variable",
    "variables : variable COMMA variables",
    "variable : SYMBOL",
    "variable : SYMBOL COLON_COLON operand",
    "local_methods : local_method",
    "local_methods : local_methods COMMA local_method",
    "local_method : method_opt named_method",
    "keyword : KEYWORD",
    "keyword : PREFIX_OPTION",
    "keyword : IMPORT_OPTION",
    "keyword : EXCLUDE_OPTION",
    "keyword : EXPORT_OPTION",
    "keyword : RENAME_OPTION",
    "expression : keyword",
    "expression : operand",
    "expression : operand binop_series",
    "binop_series : binop operand",
    "binop_series : binop_series binop operand",
    "binop : BINARY_OPERATOR",
    "binop : MINUS",
    "binop : EQUAL",
    "binop : EQUAL_EQUAL",
    "operand : MINUS operand",
    "operand : TILDE operand",
    "operand : leaf",
    "leaf : constant",
    "leaf : SYMBOL",
    "leaf : leaf LBRACKET arguments_opt RBRACKET",
    "leaf : leaf LPAREN arguments_opt RPAREN",
    "leaf : anonymous_method",
    "leaf : leaf DOT SYMBOL",
    "leaf : LPAREN expression RPAREN",
    "leaf : statement",
    "arguments_opt : /* empty */",
    "arguments_opt : arguments",
    "arguments : argument",
    "arguments : arguments COMMA argument",
    "argument : expression",
    "argument : keyword expression",
    "constant : SHARP_T",
    "constant : SHARP_F",
    "constant : concat_string",
    "constant : CHARACTER",
    "constant : INTEGER",
    "constant : FLOAT",
    "constant : SYMBOL_LITERAL",
    "constant : SHARP_PAREN dotted_list RPAREN",
    "constant : SHARP_PAREN literals_opt RPAREN",
    "constant : SHARP_BRACKET literals_opt RBRACKET",
    "concat_string : STRING",
    "concat_string : concat_string STRING",
    "dotted_list : literals DOT literal",
    "literals_opt : /* empty */",
    "literals_opt : literals",
    "literals : literal",
    "literals : literals COMMA literal",
    "literal : constant",
    "literal : keyword",
    "statement : DBEGIN",
    "statement : DBEGIN body_opt END",
    "statement : BLOCK LPAREN symbol_opt RPAREN",
    "statement : BLOCK LPAREN symbol_opt RPAREN body block_epilog_opt END block_opt",
    "statement : CASE",
    "statement : CASE condition_body END case_opt",
    "statement : IF LPAREN expression RPAREN",
    "statement : IF LPAREN expression RPAREN body else_part_opt END if_opt",
    "statement : FOR LPAREN for_header RPAREN",
    "statement : FOR LPAREN for_header RPAREN body_opt final_part_opt END for_opt",
    "statement : SELECT LPAREN expression by_part_opt RPAREN",
    "statement : SELECT LPAREN expression by_part_opt RPAREN condition_body END select_opt",
    "statement : UNLESS LPAREN expression RPAREN",
    "statement : UNLESS LPAREN expression RPAREN body END unless_opt",
    "statement : UNTIL LPAREN expression RPAREN",
    "statement : UNTIL LPAREN expression RPAREN body_opt END until_opt",
    "statement : WHILE LPAREN expression RPAREN",
    "statement : WHILE LPAREN expression RPAREN body_opt END while_opt",
    "block_epilog_opt : /* empty */",
    "block_epilog_opt : block_epilog",
    "block_epilog : exception_clauses_opt cleanup_part exception_clauses_opt",
    "block_epilog : exception_clauses",
    "condition_body : complete_condition_clauses",
    "for_header : UNTIL expression",
    "for_header : WHILE expression",
    "for_header : for_clause",
    "for_header : for_clause COMMA for_header",
    "exception_clauses_opt : /* empty */",
    "exception_clauses_opt : exception_clauses",
    "exception_clauses : exception_clause",
    "exception_clauses : exception_clauses exception_clause",
    "exception_clause : EXCEPTION SYMBOL body",
    "exception_clause : EXCEPTION LPAREN expression property_list_opt RPAREN body",
    "exception_clause : EXCEPTION LPAREN SYMBOL COLON_COLON expression property_list_opt RPAREN body",
    "complete_condition_clauses : OTHERWISE arrow_opt body",
    "complete_condition_clauses : condition_clause semi_opt",
    "complete_condition_clauses : condition_clause SEMI complete_condition_clauses",
    "complete_condition_clauses : condition_clause SEMI incomplete_condition_clauses",
    "incomplete_condition_clauses : constituent semi_opt",
    "incomplete_condition_clauses : constituent SEMI complete_condition_clauses",
    "incomplete_condition_clauses : constituent SEMI incomplete_condition_clauses",
    "condition_clause : expression ARROW constituent",
    "condition_clause : expression COMMA condition_clause",
    "for_clause : variable EQUAL expression THEN expression",
    "for_clause : LPAREN variables RPAREN EQUAL expression THEN expression",
    "for_clause : variable IN expression",
    "for_clause : variable KEYED_BY variable IN expression",
    "for_clause : variable FROM expression to_part_opt by_part_opt",
    "by_part : BY expression",
    "cleanup_part : CLEANUP body",
    "final_part : FINALLY body",
    "else_part : ELSE body",
    "else_part : ELSEIF LPAREN expression RPAREN body else_part_opt",
    "to_part_opt : /* empty */",
    "to_part_opt : TO expression",
    "to_part_opt : ABOVE expression",
    "to_part_opt : BELOW expression",
    "class_definition : SYMBOL LPAREN superclasses RPAREN class_guts_opt END class_opt symbol_opt",
    "superclasses : expression",
    "superclasses : superclasses COMMA expression",
    "class_guts_opt : /* empty */",
    "class_guts_opt : class_guts semi_opt",
    "class_guts : slot_spec",
    "class_guts : initarg_spec",
    "class_guts : inherited_spec",
    "class_guts : class_guts SEMI slot_spec",
    "class_guts : class_guts SEMI initarg_spec",
    "class_guts : class_guts SEMI inherited_spec",
    "slot_spec : flags allocation SLOT SYMBOL slot_type_opt property_list_opt",
    "initarg_spec : required_opt KEYWORD_RESERVED_WORD KEYWORD property_list_opt",
    "required_opt : REQUIRED",
    "required_opt : /* empty */",
    "inherited_spec : INHERITED SLOT SYMBOL property_list_opt",
    "allocation : /* empty */",
    "allocation : INSTANCE",
    "allocation : CLASS",
    "allocation : SUBCLASS",
    "allocation : CONSTANT",
    "allocation : VIRTUAL",
    "slot_type_opt : /* empty */",
    "slot_type_opt : COLON_COLON expression",
    "property_list_opt : /* empty */",
    "property_list_opt : property_list",
    "property_list : COMMA keyword expression",
    "property_list : property_list COMMA keyword expression",
    "generic_function_definition : SYMBOL LPAREN gf_parameters RPAREN gf_suffix",
    "gf_suffix : property_list_opt",
    "gf_suffix : ARROW return_type_element property_list_opt",
    "gf_suffix : ARROW LPAREN return_type_list RPAREN property_list_opt",
    "gf_parameters : /* empty */",
    "gf_parameters : positional_parameter more_gf_parameters",
    "gf_parameters : gf_rest_parameters",
    "more_gf_parameters : /* empty */",
    "more_gf_parameters : COMMA positional_parameter more_gf_parameters",
    "more_gf_parameters : COMMA gf_rest_parameters",
    "gf_rest_parameters : rest_parameter",
    "gf_rest_parameters : rest_parameter COMMA gf_keyword_parameters_list",
    "gf_rest_parameters : gf_keyword_parameters_list",
    "gf_keyword_parameters_list : KEY gf_keyword_parameters_opt",
    "gf_keyword_parameters_list : ALL_KEYS",
    "gf_keyword_parameters_opt : /* empty */",
    "gf_keyword_parameters_opt : gf_keyword_parameters",
    "gf_keyword_parameters : gf_keyword_parameter",
    "gf_keyword_parameters : gf_keyword_parameter COMMA ALL_KEYS",
    "gf_keyword_parameters : gf_keyword_parameter COMMA gf_keyword_parameters",
    "gf_keyword_parameter : keyword symbol_opt keyword_parameter_type",
    "gf_keyword_parameter : SYMBOL keyword_parameter_type",
    "anonymous_method : METHOD method_description END method_opt",
    "named_method : SYMBOL method_description END method_opt symbol_opt",
    "method_description : LPAREN parameters RPAREN return_type SEMI body",
    "method_description : LPAREN parameters RPAREN return_type semi_opt",
    "method_description : LPAREN parameters RPAREN semi_opt body_opt",
    "return_type : ARROW return_type_list",
    "return_type : ARROW LPAREN return_type_list RPAREN",
    "return_type_list : /* empty */",
    "return_type_list : REST return_type_element",
    "return_type_list : return_type_list_head",
    "return_type_list : return_type_list_head COMMA REST return_type_element",
    "return_type_list_head : return_type_element",
    "return_type_list_head : return_type_list_head COMMA return_type_element",
    "return_type_element : SYMBOL",
    "return_type_element : SYMBOL COLON_COLON expression",
    "parameters : /* empty */",
    "parameters : positional_parameter more_parameters",
    "parameters : next_parameters",
    "more_parameters : /* empty */",
    "more_parameters : COMMA positional_parameter more_parameters",
    "more_parameters : COMMA next_parameters",
    "positional_parameter : SYMBOL",
    "positional_parameter : SYMBOL COLON_COLON expression",
    "positional_parameter : SYMBOL EQUAL_EQUAL expression",
    "next_parameters : next_parameter",
    "next_parameters : next_parameter COMMA rest_parameters",
    "next_parameters : rest_parameters",
    "next_parameter : NEXT SYMBOL",
    "rest_parameters : rest_parameter",
    "rest_parameters : rest_parameter COMMA keyword_parameters_list",
    "rest_parameters : keyword_parameters_list",
    "rest_parameter : REST SYMBOL",
    "keyword_parameters_list : KEY keyword_parameters_opt",
    "keyword_parameters_list : ALL_KEYS",
    "keyword_parameters_opt : /* empty */",
    "keyword_parameters_opt : COMMA ALL_KEYS",
    "keyword_parameters_opt : keyword_parameters",
    "keyword_parameters : keyword_parameter",
    "keyword_parameters : keyword_parameter COMMA ALL_KEYS",
    "keyword_parameters : keyword_parameter COMMA keyword_parameters",
    "keyword_parameter : keyword_opt SYMBOL keyword_parameter_type keyword_parameter_default",
    "keyword_parameter : keyword_opt SYMBOL LPAREN expression RPAREN",
    "keyword_opt : /* empty */",
    "keyword_opt : keyword",
    "keyword_parameter_type : /* empty */",
    "keyword_parameter_type : COLON_COLON operand",
    "keyword_parameter_default : /* empty */",
    "keyword_parameter_default : EQUAL expression",
    "module_definition : SYMBOL module_clauses_opt END module_opt symbol_opt",
    "module_opt : /* empty */",
    "module_opt : MODULE",
    "module_clauses_opt : /* empty */",
    "module_clauses_opt : module_clauses",
    "module_clauses_opt : module_clauses SEMI",
    "module_clauses : use_clause",
    "module_clauses : export_clause",
    "module_clauses : create_clause",
    "module_clauses : module_clauses SEMI use_clause",
    "module_clauses : module_clauses SEMI export_clause",
    "module_clauses : module_clauses SEMI create_clause",
    "export_clause : EXPORT variable_names",
    "create_clause : CREATE variable_names",
    "use_clause : USE SYMBOL module_use_options",
    "module_use_options : /* empty */",
    "module_use_options : module_use_options COMMA module_use_option",
    "module_use_option : prefix_option",
    "module_use_option : import_option",
    "module_use_option : exclude_option",
    "module_use_option : rename_option",
    "module_use_option : export_option",
    "prefix_option : PREFIX_OPTION STRING",
    "import_option : IMPORT_OPTION ALL",
    "import_option : IMPORT_OPTION LBRACE imports_opt RBRACE",
    "imports_opt : /* empty */",
    "imports_opt : imports",
    "imports : SYMBOL",
    "imports : SYMBOL ARROW SYMBOL",
    "imports : imports COMMA SYMBOL",
    "imports : imports COMMA SYMBOL ARROW SYMBOL",
    "exclude_option : EXCLUDE_OPTION variable_name_set",
    "export_option : EXPORT_OPTION ALL",
    "export_option : EXPORT_OPTION variable_name_set",
    "rename_option : RENAME_OPTION LBRACE RBRACE",
    "rename_option : RENAME_OPTION LBRACE rename_specs RBRACE",
    "rename_specs : SYMBOL ARROW SYMBOL",
    "rename_specs : rename_specs COMMA SYMBOL ARROW SYMBOL",
    "variable_name_set : LBRACE RBRACE",
    "variable_name_set : LBRACE variable_names RBRACE",
    "variable_names : SYMBOL",
    "variable_names : variable_names COMMA SYMBOL",
    "library_definition : SYMBOL library_clauses_opt END library_opt symbol_opt",
    "library_opt : /* empty */",
    "library_opt : LIBRARY",
    "library_clauses_opt : /* empty */",
    "library_clauses_opt : library_clauses",
    "library_clauses_opt : library_clauses SEMI",
    "library_clauses : use_clause",
    "library_clauses : export_clause",
    "library_clauses : library_clauses SEMI use_clause",
    "library_clauses : library_clauses SEMI export_clause",
    "block_opt : /* empty */",
    "block_opt : BLOCK",
    "case_opt : /* empty */",
    "case_opt : CASE",
    "if_opt : /* empty */",
    "if_opt : IF",
    "for_opt : /* empty */",
    "for_opt : FOR",
    "select_opt : /* empty */",
    "select_opt : SELECT",
    "unless_opt : /* empty */",
    "unless_opt : UNLESS",
    "until_opt : /* empty */",
    "until_opt : UNTIL",
    "while_opt : /* empty */",
    "while_opt : WHILE",
    "class_opt : /* empty */",
    "class_opt : CLASS",
    "method_opt : /* empty */",
    "method_opt : METHOD",
    "semi_opt : /* empty */",
    "semi_opt : SEMI",
    "arrow_opt : /* empty */",
    "arrow_opt : ARROW",
    "symbol_opt : /* empty */",
    "symbol_opt : SYMBOL",
    "by_part_opt : /* empty */",
    "by_part_opt : by_part",
    "else_part_opt : /* empty */",
    "else_part_opt : else_part",
    "final_part_opt : /* empty */",
    "final_part_opt : final_part",
};
#endif /* YYDEBUG */
#define YYFLAG  (-3000)
/* @(#) $Revision: 70.7 $ */

/*
** Skeleton parser driver for yacc output
*/

#if defined(NLS) && !defined(NL_SETN)
#include <msgbuf.h>
#endif

#ifndef nl_msg
#define nl_msg(i,s) (s)
#endif

/*
** yacc user known macros and defines
*/
#define YYERROR        goto yyerrlab

#ifndef __RUNTIME_YYMAXDEPTH
#define YYACCEPT    return(0)
#define YYABORT        return(1)
#else
#define YYACCEPT    {free_stacks(); return(0);}
#define YYABORT        {free_stacks(); return(1);}
#endif

#define YYBACKUP( newtoken, newvalue )\
{\
    if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
    {\
        yyerror( (nl_msg(30001,"syntax error - cannot backup")) );\
        goto yyerrlab;\
    }\
    yychar = newtoken;\
    yystate = *yyps;\
    yylval = newvalue;\
    goto yynewstate;\
}
#define YYRECOVERING()    (!!yyerrflag)
#ifndef YYDEBUG
#    define YYDEBUG    1    /* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;            /* set to 1 to get debugging */

/*
** driver internal defines
*/
/* define for YYFLAG now generated by yacc program. */
/*#define YYFLAG        (FLAGVAL)*/

/*
** global variables used by the parser
*/
# ifndef __RUNTIME_YYMAXDEPTH
__YYSCLASS YYSTYPE yyv[ YYMAXDEPTH ];    /* value stack */
__YYSCLASS int yys[ YYMAXDEPTH ];        /* state stack */
# else
__YYSCLASS YYSTYPE *yyv;            /* pointer to malloc'ed value stack */
__YYSCLASS int *yys;            /* pointer to malloc'ed stack stack */

#if defined(__STDC__) || defined (__cplusplus)
#include <stdlib.h>
#else
    extern char *malloc();
    extern char *realloc();
    extern void free();
#endif /* __STDC__ or __cplusplus */


static int allocate_stacks();
static void free_stacks();
# ifndef YYINCREMENT
# define YYINCREMENT (YYMAXDEPTH/2) + 10
# endif
# endif    /* __RUNTIME_YYMAXDEPTH */
long  yymaxdepth = YYMAXDEPTH;

__YYSCLASS YYSTYPE *yypv;            /* top of value stack */
__YYSCLASS int *yyps;            /* top of state stack */

__YYSCLASS int yystate;            /* current state */
__YYSCLASS int yytmp;            /* extra var (lasts between blocks) */

int yynerrs;            /* number of errors */
__YYSCLASS int yyerrflag;            /* error recovery flag */
int yychar;            /* current input token number */



/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int
yyparse()
{
    register YYSTYPE *yypvt;    /* top of value stack for $vars */

    /*
    ** Initialize externals - yyparse may be called more than once
    */
# ifdef __RUNTIME_YYMAXDEPTH
    if (allocate_stacks()) YYABORT;
# endif
    yypv = &yyv[-1];
    yyps = &yys[-1];
    yystate = 0;
    yytmp = 0;
    yynerrs = 0;
    yyerrflag = 0;
    yychar = -1;

    goto yystack;
    {
        register YYSTYPE *yy_pv;    /* top of value stack */
        register int *yy_ps;        /* top of state stack */
        register int yy_state;        /* current state */
        register int  yy_n;        /* internal state number info */

        /*
        ** get globals into registers.
        ** branch to here only if YYBACKUP was called.
        */
    yynewstate:
        yy_pv = yypv;
        yy_ps = yyps;
        yy_state = yystate;
        goto yy_newstate;

        /*
        ** get globals into registers.
        ** either we just started, or we just finished a reduction
        */
    yystack:
        yy_pv = yypv;
        yy_ps = yyps;
        yy_state = yystate;

        /*
        ** top of for (;;) loop while no reductions done
        */
    yy_stack:
        /*
        ** put a state and value onto the stacks
        */
#if YYDEBUG
        /*
        ** if debugging, look up token value in list of value vs.
        ** name pairs.  0 and negative (-1) are special values.
        ** Note: linear search is used since time is not a real
        ** consideration while debugging.
        */
        if ( yydebug )
        {
            register int yy_i;

            printf( "State %d, token ", yy_state );
            if ( yychar == 0 )
                printf( "end-of-file\n" );
            else if ( yychar < 0 )
                printf( "-none-\n" );
            else
            {
                for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
                    yy_i++ )
                {
                    if ( yytoks[yy_i].t_val == yychar )
                        break;
                }
                printf( "%s\n", yytoks[yy_i].t_name );
            }
        }
#endif /* YYDEBUG */
        if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
        {
# ifndef __RUNTIME_YYMAXDEPTH
            yyerror( (nl_msg(30002,"yacc stack overflow")) );
            YYABORT;
# else
            /* save old stack bases to recalculate pointers */
            YYSTYPE * yyv_old = yyv;
            int * yys_old = yys;
            yymaxdepth += YYINCREMENT;
            yys = (int *) realloc(yys, yymaxdepth * sizeof(int));
            yyv = (YYSTYPE *) realloc(yyv, yymaxdepth * sizeof(YYSTYPE));
            if (yys==0 || yyv==0) {
                yyerror( (nl_msg(30002,"yacc stack overflow")) );
                YYABORT;
                }
            /* Reset pointers into stack */
            yy_ps = (yy_ps - yys_old) + yys;
            yyps = (yyps - yys_old) + yys;
            yy_pv = (yy_pv - yyv_old) + yyv;
            yypv = (yypv - yyv_old) + yyv;
# endif

        }
        *yy_ps = yy_state;
        *++yy_pv = yyval;

        /*
        ** we have a new state - find out what to do
        */
    yy_newstate:
        if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
            goto yydefault;        /* simple state */
#if YYDEBUG
        /*
        ** if debugging, need to mark whether new token grabbed
        */
        yytmp = yychar < 0;
#endif
        if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
            yychar = 0;        /* reached EOF */
#if YYDEBUG
        if ( yydebug && yytmp )
        {
            register int yy_i;

            printf( "Received token " );
            if ( yychar == 0 )
                printf( "end-of-file\n" );
            else if ( yychar < 0 )
                printf( "-none-\n" );
            else
            {
                for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
                    yy_i++ )
                {
                    if ( yytoks[yy_i].t_val == yychar )
                        break;
                }
                printf( "%s\n", yytoks[yy_i].t_name );
            }
        }
#endif /* YYDEBUG */
        if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
            goto yydefault;
        if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
        {
            yychar = -1;
            yyval = yylval;
            yy_state = yy_n;
            if ( yyerrflag > 0 )
                yyerrflag--;
            goto yy_stack;
        }

    yydefault:
        if ( ( yy_n = yydef[ yy_state ] ) == -2 )
        {
#if YYDEBUG
            yytmp = yychar < 0;
#endif
            if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
                yychar = 0;        /* reached EOF */
#if YYDEBUG
            if ( yydebug && yytmp )
            {
                register int yy_i;

                printf( "Received token " );
                if ( yychar == 0 )
                    printf( "end-of-file\n" );
                else if ( yychar < 0 )
                    printf( "-none-\n" );
                else
                {
                    for ( yy_i = 0;
                        yytoks[yy_i].t_val >= 0;
                        yy_i++ )
                    {
                        if ( yytoks[yy_i].t_val
                            == yychar )
                        {
                            break;
                        }
                    }
                    printf( "%s\n", yytoks[yy_i].t_name );
                }
            }
#endif /* YYDEBUG */
            /*
            ** look through exception table
            */
            {
                register int *yyxi = yyexca;

                while ( ( *yyxi != -1 ) ||
                    ( yyxi[1] != yy_state ) )
                {
                    yyxi += 2;
                }
                while ( ( *(yyxi += 2) >= 0 ) &&
                    ( *yyxi != yychar ) )
                    ;
                if ( ( yy_n = yyxi[1] ) < 0 )
                    YYACCEPT;
            }
        }

        /*
        ** check for syntax error
        */
        if ( yy_n == 0 )    /* have an error */
        {
            /* no worry about speed here! */
            switch ( yyerrflag )
            {
            case 0:        /* new error */
                yyerror( (nl_msg(30003,"syntax error")) );
                yynerrs++;
                goto skip_init;
            yyerrlab:
                /*
                ** get globals into registers.
                ** we have a user generated syntax type error
                */
                yy_pv = yypv;
                yy_ps = yyps;
                yy_state = yystate;
                yynerrs++;
            skip_init:
            case 1:
            case 2:        /* incompletely recovered error */
                    /* try again... */
                yyerrflag = 3;
                /*
                ** find state where "error" is a legal
                ** shift action
                */
                while ( yy_ps >= yys )
                {
                    yy_n = yypact[ *yy_ps ] + YYERRCODE;
                    if ( yy_n >= 0 && yy_n < YYLAST &&
                        yychk[yyact[yy_n]] == YYERRCODE)                    {
                        /*
                        ** simulate shift of "error"
                        */
                        yy_state = yyact[ yy_n ];
                        goto yy_stack;
                    }
                    /*
                    ** current state has no shift on
                    ** "error", pop stack
                    */
#if YYDEBUG
#    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
                    if ( yydebug )
                        printf( _POP_, *yy_ps,
                            yy_ps[-1] );
#    undef _POP_
#endif
                    yy_ps--;
                    yy_pv--;
                }
                /*
                ** there is no state on stack with "error" as
                ** a valid shift.  give up.
                */
                YYABORT;
            case 3:        /* no shift yet; eat a token */
#if YYDEBUG
                /*
                ** if debugging, look up token in list of
                ** pairs.  0 and negative shouldn't occur,
                ** but since timing doesn't matter when
                ** debugging, it doesn't hurt to leave the
                ** tests here.
                */
                if ( yydebug )
                {
                    register int yy_i;

                    printf( "Error recovery discards " );
                    if ( yychar == 0 )
                        printf( "token end-of-file\n" );
                    else if ( yychar < 0 )
                        printf( "token -none-\n" );
                    else
                    {
                        for ( yy_i = 0;
                            yytoks[yy_i].t_val >= 0;
                            yy_i++ )
                        {
                            if ( yytoks[yy_i].t_val
                                == yychar )
                            {
                                break;
                            }
                        }
                        printf( "token %s\n",
                            yytoks[yy_i].t_name );
                    }
                }
#endif /* YYDEBUG */
                if ( yychar == 0 )    /* reached EOF. quit */
                    YYABORT;
                yychar = -1;
                goto yy_newstate;
            }
        }/* end if ( yy_n == 0 ) */
        /*
        ** reduction by production yy_n
        ** put stack tops, etc. so things right after switch
        */
#if YYDEBUG
        /*
        ** if debugging, print the string that is the user's
        ** specification of the reduction which is just about
        ** to be done.
        */
        if ( yydebug )
            printf( "Reduce by (%d) \"%s\"\n",
                yy_n, yyreds[ yy_n ] );
#endif
        yytmp = yy_n;            /* value to switch over */
        yypvt = yy_pv;            /* $vars top of value stack */
        /*
        ** Look in goto table for next state
        ** Sorry about using yy_state here as temporary
        ** register variable, but why not, if it works...
        ** If yyr2[ yy_n ] doesn't have the low order bit
        ** set, then there is no action to be done for
        ** this reduction.  So, no saving & unsaving of
        ** registers done.  The only difference between the
        ** code just after the if and the body of the if is
        ** the goto yy_stack in the body.  This way the test
        ** can be made before the choice of what to do is needed.
        */
        {
            /* length of production doubled with extra bit */
            register int yy_len = yyr2[ yy_n ];

            if ( !( yy_len & 01 ) )
            {
                yy_len >>= 1;
                yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
                yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
                    *( yy_ps -= yy_len ) + 1;
                if ( yy_state >= YYLAST ||
                    yychk[ yy_state =
                    yyact[ yy_state ] ] != -yy_n )
                {
                    yy_state = yyact[ yypgo[ yy_n ] ];
                }
                goto yy_stack;
            }
            yy_len >>= 1;
            yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
            yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
                *( yy_ps -= yy_len ) + 1;
            if ( yy_state >= YYLAST ||
                yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
            {
                yy_state = yyact[ yypgo[ yy_n ] ];
            }
        }
                    /* save until reenter driver code */
        yystate = yy_state;
        yyps = yy_ps;
        yypv = yy_pv;
    }
    /*
    ** code supplied by user is placed in this switch
    */
    switch( yytmp )
    {

case 2:
# line 280 "../../mindy-1.x/comp/parser.y"
{ process_header(NULL, NULL); free(yypvt[-0].token); } break;
case 3:
# line 281 "../../mindy-1.x/comp/parser.y"
{ process_header(NULL, NULL); free(yypvt[-0].token); } break;
case 4:
# line 286 "../../mindy-1.x/comp/parser.y"
{ process_header((char *)yypvt[-1].token->chars, (char *)yypvt[-0].token->chars); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 5:
# line 288 "../../mindy-1.x/comp/parser.y"
{ process_header((char *)yypvt[-1].token->chars, (char *)yypvt[-0].token->chars); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 6:
# line 292 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(SEMI); } break;
case 7:
# line 293 "../../mindy-1.x/comp/parser.y"
{ Program = yypvt[-0].body; yyval.nothing = NULL; } break;
case 8:
# line 297 "../../mindy-1.x/comp/parser.y"
{ yyval.body = yypvt[-1].body; } break;
case 9:
# line 301 "../../mindy-1.x/comp/parser.y"
{ yyval.body = make_body(); } break;
case 10:
# line 302 "../../mindy-1.x/comp/parser.y"
{ yyval.body = yypvt[-0].body; } break;
case 11:
# line 308 "../../mindy-1.x/comp/parser.y"
{ yyval.body = add_constituent(make_body(), yypvt[-0].constituent); } break;
case 12:
# line 310 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.body = add_constituent(yypvt[-2].body, yypvt[-0].constituent); } break;
case 13:
# line 314 "../../mindy-1.x/comp/parser.y"
{ yyval.constituent = yypvt[-0].constituent; } break;
case 14:
# line 315 "../../mindy-1.x/comp/parser.y"
{ yyval.constituent = yypvt[-0].constituent; } break;
case 15:
# line 316 "../../mindy-1.x/comp/parser.y"
{ yyval.constituent = make_expr_constituent(yypvt[-0].expr); } break;
case 16:
# line 317 "../../mindy-1.x/comp/parser.y"
{ yyval.constituent = make_error_constituent(); } break;
case 17:
# line 322 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token); yyval.constituent = set_class_flags(yypvt[-2].flags, yypvt[-0].constituent); } break;
case 18:
# line 324 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.constituent = make_define_constant(yypvt[-1].token->line, yypvt[-0].bindings); free(yypvt[-1].token); } break;
case 19:
# line 326 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token); yyval.constituent = set_generic_flags(yypvt[-2].flags, yypvt[-0].constituent); } break;
case 20:
# line 328 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token); yyval.constituent = make_define_method(yypvt[-2].flags, yypvt[-0].method); } break;
case 21:
# line 330 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.constituent = make_define_variable(yypvt[-1].token->line, yypvt[-0].bindings); free(yypvt[-1].token); } break;
case 22:
# line 332 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-1].token); yyval.constituent = yypvt[-0].constituent; } break;
case 23:
# line 334 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-1].token); yyval.constituent = yypvt[-0].constituent; } break;
case 24:
# line 338 "../../mindy-1.x/comp/parser.y"
{ yyval.flags = 0; } break;
case 25:
# line 339 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_SEALED; } break;
case 26:
# line 340 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_OPEN; } break;
case 27:
# line 341 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_ABSTRACT; } break;
case 28:
# line 342 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_CONCRETE; } break;
case 29:
# line 343 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_PRIMARY; } break;
case 30:
# line 344 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.flags = yypvt[-1].flags | flag_FREE; } break;
case 31:
# line 349 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.constituent = make_let(yypvt[-0].bindings); } break;
case 32:
# line 351 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-3].token); free(yypvt[-1].token);
      yyval.constituent = make_handler(make_varref(make_id(yypvt[-2].token)), yypvt[-0].expr, NULL);
    } break;
case 33:
# line 355 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token); free(yypvt[-6].token); free(yypvt[-5].token); free(yypvt[-2].token); free(yypvt[-1].token);
      yyval.constituent = make_handler(yypvt[-4].expr, yypvt[-0].expr, yypvt[-3].plist);
    } break;
case 34:
# line 359 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.constituent = make_local_constituent(yypvt[-0].local_methods); } break;
case 35:
# line 364 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.bindings = make_bindings(push_param(yypvt[-2].param,make_param_list()), yypvt[-0].expr); } break;
case 36:
# line 366 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-2].token); free(yypvt[-1].token); yyval.bindings = make_bindings(yypvt[-3].param_list, yypvt[-0].expr); } break;
case 37:
# line 371 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = set_rest_param(make_param_list(), yypvt[-0].id); } break;
case 38:
# line 373 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = push_param(yypvt[-0].param, make_param_list()); } break;
case 39:
# line 375 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = push_param(yypvt[-2].param, yypvt[-0].param_list); } break;
case 40:
# line 379 "../../mindy-1.x/comp/parser.y"
{ yyval.param = make_param(make_id(yypvt[-0].token), NULL); } break;
case 41:
# line 381 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param = make_param(make_id(yypvt[-2].token), yypvt[-0].expr); } break;
case 42:
# line 385 "../../mindy-1.x/comp/parser.y"
{ yyval.local_methods = add_local_method(make_local_methods(), yypvt[-0].method); } break;
case 43:
# line 387 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.local_methods = add_local_method(yypvt[-2].local_methods, yypvt[-0].method); } break;
case 44:
# line 391 "../../mindy-1.x/comp/parser.y"
{ yyval.method = yypvt[-0].method; } break;
case 51:
# line 404 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = make_literal_ref(parse_keyword_token(yypvt[-0].token)); } break;
case 52:
# line 405 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = yypvt[-0].expr; } break;
case 53:
# line 407 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = make_binop_series_expr(yypvt[-1].expr, yypvt[-0].binop_series); } break;
case 54:
# line 411 "../../mindy-1.x/comp/parser.y"
{ yyval.binop_series = add_binop(make_binop_series(), yypvt[-1].binop, yypvt[-0].expr); } break;
case 55:
# line 412 "../../mindy-1.x/comp/parser.y"
{ yyval.binop_series = add_binop(yypvt[-2].binop_series, yypvt[-1].binop, yypvt[-0].expr); } break;
case 56:
# line 416 "../../mindy-1.x/comp/parser.y"
{ yyval.binop = make_binop(make_id(yypvt[-0].token)); } break;
case 57:
# line 417 "../../mindy-1.x/comp/parser.y"
{ yyval.binop = make_binop(make_id(yypvt[-0].token)); } break;
case 58:
# line 418 "../../mindy-1.x/comp/parser.y"
{ yyval.binop = make_binop(make_id(yypvt[-0].token)); } break;
case 59:
# line 419 "../../mindy-1.x/comp/parser.y"
{ yyval.binop = make_binop(make_id(yypvt[-0].token)); } break;
case 60:
# line 423 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = make_negate(yypvt[-0].expr); } break;
case 61:
# line 424 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = make_not(yypvt[-0].expr); } break;
case 62:
# line 425 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = yypvt[-0].expr; } break;
case 63:
# line 429 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = make_literal_ref(yypvt[-0].literal); } break;
case 64:
# line 430 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = make_varref(make_id(yypvt[-0].token)); } break;
case 65:
# line 432 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token); yyval.expr = make_aref_or_element(yypvt[-3].expr, yypvt[-1].arglist); } break;
case 66:
# line 434 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token); yyval.expr = make_function_call(yypvt[-3].expr, yypvt[-1].arglist); } break;
case 67:
# line 435 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = make_method_ref(yypvt[-0].method); } break;
case 68:
# line 437 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token);
      yyval.expr = make_dot_operation(yypvt[-2].expr, make_varref(make_id(yypvt[-0].token)));
    } break;
case 69:
# line 440 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = yypvt[-1].expr; free(yypvt[-2].token); free(yypvt[-0].token); } break;
case 70:
# line 441 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = yypvt[-0].expr; } break;
case 71:
# line 445 "../../mindy-1.x/comp/parser.y"
{ yyval.arglist = make_argument_list(); } break;
case 72:
# line 446 "../../mindy-1.x/comp/parser.y"
{ yyval.arglist = yypvt[-0].arglist; } break;
case 73:
# line 450 "../../mindy-1.x/comp/parser.y"
{ yyval.arglist = add_argument(make_argument_list(), yypvt[-0].argument); } break;
case 74:
# line 451 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.arglist = add_argument(yypvt[-2].arglist, yypvt[-0].argument); } break;
case 75:
# line 455 "../../mindy-1.x/comp/parser.y"
{ yyval.argument = make_argument(yypvt[-0].expr); } break;
case 76:
# line 457 "../../mindy-1.x/comp/parser.y"
{ yyval.argument = make_keyword_argument(yypvt[-1].token, yypvt[-0].expr); } break;
case 77:
# line 461 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_true_token(yypvt[-0].token); } break;
case 78:
# line 462 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_false_token(yypvt[-0].token); } break;
case 79:
# line 463 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = yypvt[-0].literal; } break;
case 80:
# line 464 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_character_token(yypvt[-0].token); } break;
case 81:
# line 465 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_integer_token(yypvt[-0].token); } break;
case 82:
# line 466 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_float_token(yypvt[-0].token); } break;
case 83:
# line 467 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_keyword_token(yypvt[-0].token); } break;
case 84:
# line 469 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token); yyval.literal = yypvt[-1].literal; } break;
case 85:
# line 471 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token); yyval.literal = make_list_literal(yypvt[-1].literal_list); } break;
case 86:
# line 473 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token); yyval.literal = make_vector_literal(yypvt[-1].literal_list); } break;
case 87:
# line 477 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_string_token(yypvt[-0].token); } break;
case 88:
# line 478 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = concat_string_token(yypvt[-1].literal, yypvt[-0].token); } break;
case 89:
# line 482 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.literal = make_dotted_list_literal(yypvt[-2].literal_list, yypvt[-0].literal); } break;
case 90:
# line 487 "../../mindy-1.x/comp/parser.y"
{ yyval.literal_list = make_literal_list(); } break;
case 91:
# line 489 "../../mindy-1.x/comp/parser.y"
{ yyval.literal_list = yypvt[-0].literal_list; } break;
case 92:
# line 493 "../../mindy-1.x/comp/parser.y"
{ yyval.literal_list = add_literal(make_literal_list(), yypvt[-0].literal); } break;
case 93:
# line 495 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.literal_list = add_literal(yypvt[-2].literal_list, yypvt[-0].literal); } break;
case 94:
# line 499 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = yypvt[-0].literal; } break;
case 95:
# line 500 "../../mindy-1.x/comp/parser.y"
{ yyval.literal = parse_keyword_token(yypvt[-0].token); } break;
case 96:
# line 504 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END); } break;
case 97:
# line 506 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-0].token); yyval.expr = make_body_expr(yypvt[-1].body);
          pop_yacc_recoveries(1); } break;
case 98:
# line 508 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END);
                     push_yacc_recovery(CLEANUP);
                     push_yacc_recovery(EXCEPTION); } break;
case 99:
# line 512 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token); free(yypvt[-5].token); free(yypvt[-1].token); pop_yacc_recoveries(3);
      yyval.expr = make_block(yypvt[-8].token->line, yypvt[-6].token ? make_id(yypvt[-6].token) : NULL, yypvt[-3].body, yypvt[-2].block_epilog);
      free(yypvt[-8].token);
    } break;
case 100:
# line 516 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END); } break;
case 101:
# line 518 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-1].token); yyval.expr = make_case(yypvt[-2].condition_body);
          pop_yacc_recoveries(1); } break;
case 102:
# line 520 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END);
                      push_yacc_recovery(ELSE); } break;
case 103:
# line 523 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-8].token); free(yypvt[-7].token); free(yypvt[-5].token); free(yypvt[-1].token); yyval.expr = make_if(yypvt[-6].expr, yypvt[-3].body, yypvt[-2].else_part);
          pop_yacc_recoveries(2); } break;
case 104:
# line 525 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END);
                       push_yacc_recovery(FINALLY); } break;
case 105:
# line 528 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-8].token); free(yypvt[-7].token); free(yypvt[-5].token); free(yypvt[-1].token); yyval.expr = make_for(yypvt[-6].for_header, yypvt[-3].body, yypvt[-2].body);
          pop_yacc_recoveries(2); } break;
case 106:
# line 530 "../../mindy-1.x/comp/parser.y"
{push_yacc_recovery(END);} break;
case 107:
# line 532 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-8].token);free(yypvt[-7].token);free(yypvt[-4].token);free(yypvt[-1].token); yyval.expr = make_select(yypvt[-6].expr, yypvt[-5].expr, yypvt[-2].condition_body);
          pop_yacc_recoveries(1); } break;
case 108:
# line 534 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END); } break;
case 109:
# line 536 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token);free(yypvt[-6].token);free(yypvt[-4].token);free(yypvt[-1].token);
      yyval.expr = make_if(yypvt[-5].expr, NULL, make_else(0, yypvt[-2].body));
          pop_yacc_recoveries(1); } break;
case 110:
# line 539 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END); } break;
case 111:
# line 541 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token);free(yypvt[-6].token);free(yypvt[-4].token);free(yypvt[-1].token); pop_yacc_recoveries(1);
      yyval.expr = make_for(make_for_header(yypvt[-5].expr), yypvt[-2].body, NULL);
    } break;
case 112:
# line 544 "../../mindy-1.x/comp/parser.y"
{ push_yacc_recovery(END); } break;
case 113:
# line 546 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token);free(yypvt[-6].token);free(yypvt[-4].token);free(yypvt[-1].token);pop_yacc_recoveries(1);
      yyval.expr = make_for(make_for_header(make_not(yypvt[-5].expr)), yypvt[-2].body, NULL);
    } break;
case 114:
# line 552 "../../mindy-1.x/comp/parser.y"
{ yyval.block_epilog = NULL; } break;
case 115:
# line 553 "../../mindy-1.x/comp/parser.y"
{ yyval.block_epilog = yypvt[-0].block_epilog; } break;
case 116:
# line 558 "../../mindy-1.x/comp/parser.y"
{ yyval.block_epilog = make_block_epilog(yypvt[-2].exception_clauses, yypvt[-1].body, yypvt[-0].exception_clauses); } break;
case 117:
# line 560 "../../mindy-1.x/comp/parser.y"
{ yyval.block_epilog = make_block_epilog(yypvt[-0].exception_clauses, NULL, NULL); } break;
case 118:
# line 564 "../../mindy-1.x/comp/parser.y"
{ yyval.condition_body = yypvt[-0].condition_body; } break;
case 119:
# line 569 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.for_header = make_for_header(yypvt[-0].expr); } break;
case 120:
# line 571 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.for_header = make_for_header(make_not(yypvt[-0].expr)); } break;
case 121:
# line 573 "../../mindy-1.x/comp/parser.y"
{ yyval.for_header = push_for_clause(yypvt[-0].for_clause, make_for_header(NULL)); } break;
case 122:
# line 575 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.for_header = push_for_clause(yypvt[-2].for_clause, yypvt[-0].for_header); } break;
case 123:
# line 579 "../../mindy-1.x/comp/parser.y"
{ yyval.exception_clauses = NULL; } break;
case 124:
# line 580 "../../mindy-1.x/comp/parser.y"
{ yyval.exception_clauses = yypvt[-0].exception_clauses; } break;
case 125:
# line 585 "../../mindy-1.x/comp/parser.y"
{ yyval.exception_clauses = add_exception_clause(make_exception_clauses(), yypvt[-0].exception_clause); } break;
case 126:
# line 587 "../../mindy-1.x/comp/parser.y"
{ yyval.exception_clauses = add_exception_clause(yypvt[-1].exception_clauses, yypvt[-0].exception_clause); } break;
case 127:
# line 592 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token);
      yyval.exception_clause = make_exception_clause(make_varref(make_id(yypvt[-1].token)),
                     NULL, NULL, yypvt[-0].body);
    } break;
case 128:
# line 597 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-5].token); free(yypvt[-4].token); free(yypvt[-1].token);
      yyval.exception_clause = make_exception_clause(yypvt[-3].expr, NULL, yypvt[-2].plist, yypvt[-0].body);
    } break;
case 129:
# line 602 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-7].token); free(yypvt[-6].token); free(yypvt[-4].token); free(yypvt[-1].token);
      yyval.exception_clause = make_exception_clause(yypvt[-3].expr, make_id(yypvt[-5].token), yypvt[-2].plist, yypvt[-0].body);
    } break;
case 130:
# line 609 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token);
      yyval.condition_body = push_condition_clause(make_otherwise_condition_clause(yypvt[-0].body),
                     NULL);
    } break;
case 131:
# line 614 "../../mindy-1.x/comp/parser.y"
{ yyval.condition_body = push_condition_clause(yypvt[-1].condition_clause, NULL); } break;
case 132:
# line 616 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.condition_body = push_condition_clause(yypvt[-2].condition_clause, yypvt[-0].condition_body); } break;
case 133:
# line 618 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.condition_body = complete_condition_clauses(yypvt[-2].condition_clause, yypvt[-0].incomplete_condition_body); } break;
case 134:
# line 623 "../../mindy-1.x/comp/parser.y"
{ yyval.incomplete_condition_body = make_incomplete_condition_clauses(yypvt[-1].constituent, NULL); } break;
case 135:
# line 625 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.incomplete_condition_body = make_incomplete_condition_clauses(yypvt[-2].constituent, yypvt[-0].condition_body); } break;
case 136:
# line 627 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.incomplete_condition_body = push_condition_constituent(yypvt[-2].constituent, yypvt[-0].incomplete_condition_body); } break;
case 137:
# line 632 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.condition_clause = push_condition(yypvt[-2].expr, make_condition_clause(yypvt[-0].constituent)); } break;
case 138:
# line 634 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.condition_clause = push_condition(yypvt[-2].expr, yypvt[-0].condition_clause); } break;
case 139:
# line 639 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token);
    yyval.for_clause=make_equal_then_for_clause(push_param(yypvt[-4].param,make_param_list()),yypvt[-2].expr,yypvt[-0].expr);} break;
case 140:
# line 642 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-6].token); free(yypvt[-4].token); free(yypvt[-3].token); free(yypvt[-1].token);
      yyval.for_clause = make_equal_then_for_clause(yypvt[-5].param_list, yypvt[-2].expr, yypvt[-0].expr); } break;
case 141:
# line 645 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.for_clause = make_in_for_clause(yypvt[-2].param, NULL, yypvt[-0].expr); } break;
case 142:
# line 647 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token); yyval.for_clause = make_in_for_clause(yypvt[-4].param, yypvt[-2].param, yypvt[-0].expr); } break;
case 143:
# line 649 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); yyval.for_clause = make_from_for_clause(yypvt[-4].param, yypvt[-2].expr, yypvt[-1].to_part, yypvt[-0].expr); } break;
case 144:
# line 652 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = yypvt[-0].expr; } break;
case 145:
# line 653 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.body = yypvt[-0].body; } break;
case 146:
# line 654 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.body = yypvt[-0].body; } break;
case 147:
# line 657 "../../mindy-1.x/comp/parser.y"
{ yyval.else_part = make_else(yypvt[-1].token->line, yypvt[-0].body); free(yypvt[-1].token); } break;
case 148:
# line 659 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-2].token);
      yyval.else_part = make_else(yypvt[-5].token->line, make_expr_body(make_if(yypvt[-3].expr, yypvt[-1].body, yypvt[-0].else_part)));
      free(yypvt[-5].token);
    } break;
case 149:
# line 666 "../../mindy-1.x/comp/parser.y"
{ yyval.to_part = NULL; } break;
case 150:
# line 667 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.to_part = make_to(yypvt[-0].expr); } break;
case 151:
# line 668 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.to_part = make_above(yypvt[-0].expr); } break;
case 152:
# line 669 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.to_part = make_below(yypvt[-0].expr); } break;
case 153:
# line 675 "../../mindy-1.x/comp/parser.y"
{ struct id *id = make_id(yypvt[-7].token);
      verify_symbol(id, yypvt[-0].token); free(yypvt[-6].token); free(yypvt[-4].token); free(yypvt[-2].token);
      yyval.constituent = make_class_definition(id, yypvt[-5].superclass_list, yypvt[-3].class_guts);
    } break;
case 154:
# line 683 "../../mindy-1.x/comp/parser.y"
{ yyval.superclass_list = add_superclass(make_superclass_list(), yypvt[-0].expr); } break;
case 155:
# line 685 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.superclass_list = add_superclass(yypvt[-2].superclass_list, yypvt[-0].expr); } break;
case 156:
# line 689 "../../mindy-1.x/comp/parser.y"
{ yyval.class_guts = NULL; } break;
case 157:
# line 690 "../../mindy-1.x/comp/parser.y"
{ yyval.class_guts = yypvt[-1].class_guts; } break;
case 158:
# line 695 "../../mindy-1.x/comp/parser.y"
{ yyval.class_guts = add_slot_spec(make_class_guts(), yypvt[-0].slot_spec); } break;
case 159:
# line 697 "../../mindy-1.x/comp/parser.y"
{ yyval.class_guts = add_initarg_spec(make_class_guts(), yypvt[-0].initarg_spec); } break;
case 160:
# line 699 "../../mindy-1.x/comp/parser.y"
{ yyval.class_guts = add_inherited_spec(make_class_guts(), yypvt[-0].inherited_spec); } break;
case 161:
# line 701 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.class_guts = add_slot_spec(yypvt[-2].class_guts, yypvt[-0].slot_spec); } break;
case 162:
# line 703 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.class_guts = add_initarg_spec(yypvt[-2].class_guts, yypvt[-0].initarg_spec); } break;
case 163:
# line 705 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.class_guts = add_inherited_spec(yypvt[-2].class_guts, yypvt[-0].inherited_spec); } break;
case 164:
# line 710 "../../mindy-1.x/comp/parser.y"
{
        int line = yypvt[-3].token->line;
        free(yypvt[-3].token);
        yyval.slot_spec = make_slot_spec(line, yypvt[-5].flags, yypvt[-4].slot_allocation, yypvt[-2].token ? make_id(yypvt[-2].token) : NULL, yypvt[-1].expr, yypvt[-0].plist);
    } break;
case 165:
# line 719 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.initarg_spec = make_initarg_spec(yypvt[-3].bool, yypvt[-1].token, yypvt[-0].plist); } break;
case 166:
# line 723 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.bool = TRUE; } break;
case 167:
# line 724 "../../mindy-1.x/comp/parser.y"
{ yyval.bool = FALSE; } break;
case 168:
# line 729 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-2].token); yyval.inherited_spec = make_inherited_spec(make_id(yypvt[-1].token), yypvt[-0].plist); } break;
case 169:
# line 734 "../../mindy-1.x/comp/parser.y"
{ yyval.slot_allocation = alloc_INSTANCE; } break;
case 170:
# line 735 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.slot_allocation = alloc_INSTANCE; } break;
case 171:
# line 736 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.slot_allocation = alloc_CLASS; } break;
case 172:
# line 737 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.slot_allocation = alloc_SUBCLASS; } break;
case 173:
# line 738 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.slot_allocation = alloc_CONSTANT; } break;
case 174:
# line 739 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.slot_allocation = alloc_VIRTUAL; } break;
case 175:
# line 743 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = NULL; } break;
case 176:
# line 744 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = yypvt[-0].expr; } break;
case 177:
# line 748 "../../mindy-1.x/comp/parser.y"
{ yyval.plist = make_property_list(); } break;
case 178:
# line 749 "../../mindy-1.x/comp/parser.y"
{ yyval.plist = yypvt[-0].plist; } break;
case 179:
# line 754 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.plist = add_property(make_property_list(), yypvt[-1].token, yypvt[-0].expr); } break;
case 180:
# line 756 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.plist = add_property(yypvt[-3].plist, yypvt[-1].token, yypvt[-0].expr); } break;
case 181:
# line 761 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-1].token);
      yyval.constituent = make_define_generic(make_id(yypvt[-4].token), yypvt[-2].param_list, yypvt[-0].gf_suffix);
    } break;
case 182:
# line 768 "../../mindy-1.x/comp/parser.y"
{ yyval.gf_suffix = make_gf_suffix(NULL, yypvt[-0].plist); } break;
case 183:
# line 770 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token);
      yyval.gf_suffix = make_gf_suffix
              (add_return_type(make_return_type_list(FALSE, NULL), yypvt[-1].expr),
           yypvt[-0].plist);
    } break;
case 184:
# line 776 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-3].token); free(yypvt[-1].token); yyval.gf_suffix = make_gf_suffix(yypvt[-2].return_type_list, yypvt[-0].plist); } break;
case 185:
# line 780 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = make_param_list(); } break;
case 186:
# line 782 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = push_param(yypvt[-1].param, yypvt[-0].param_list); } break;
case 187:
# line 783 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 188:
# line 788 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = make_param_list(); } break;
case 189:
# line 790 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.param_list = push_param(yypvt[-1].param, yypvt[-0].param_list); } break;
case 190:
# line 792 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = yypvt[-0].param_list; } break;
case 191:
# line 797 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = set_rest_param(make_param_list(), yypvt[-0].id); } break;
case 192:
# line 799 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = set_rest_param(yypvt[-0].param_list, yypvt[-2].id); } break;
case 193:
# line 801 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 194:
# line 805 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = yypvt[-0].param_list; } break;
case 195:
# line 806 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.param_list = allow_all_keywords(make_param_list()); } break;
case 196:
# line 810 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = allow_keywords(make_param_list()); } break;
case 197:
# line 811 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 198:
# line 816 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = push_keyword_param(yypvt[-0].keyword_param, allow_keywords(make_param_list())); } break;
case 199:
# line 818 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); free(yypvt[-0].token);
      yyval.param_list = push_keyword_param(yypvt[-2].keyword_param, allow_all_keywords(make_param_list())); } break;
case 200:
# line 821 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = push_keyword_param(yypvt[-2].keyword_param, yypvt[-0].param_list); } break;
case 201:
# line 826 "../../mindy-1.x/comp/parser.y"
{ yyval.keyword_param = make_keyword_param(yypvt[-2].token, yypvt[-1].token ? make_id(yypvt[-1].token) : NULL, yypvt[-0].expr, NULL); } break;
case 202:
# line 828 "../../mindy-1.x/comp/parser.y"
{ yyval.keyword_param = make_keyword_param(NULL, make_id(yypvt[-1].token), yypvt[-0].expr, NULL); } break;
case 203:
# line 833 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.method = set_method_source(yypvt[-3].token, yypvt[-2].method); } break;
case 204:
# line 838 "../../mindy-1.x/comp/parser.y"
{ struct id *id = make_id(yypvt[-4].token);
      free(yypvt[-2].token); verify_symbol(id, yypvt[-0].token);
      yyval.method = set_method_name(id, yypvt[-3].method);
    } break;
case 205:
# line 846 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-5].token); free(yypvt[-3].token); free(yypvt[-1].token);
      yyval.method = make_method_description(yypvt[-4].param_list, yypvt[-2].return_type_list, yypvt[-0].body);
    } break;
case 206:
# line 850 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-2].token);
      yyval.method = make_method_description(yypvt[-3].param_list, yypvt[-1].return_type_list, make_body());
    } break;
case 207:
# line 854 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-4].token); free(yypvt[-2].token);
      yyval.method = make_method_description(yypvt[-3].param_list, NULL, yypvt[-0].body);
    } break;
case 208:
# line 861 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.return_type_list = yypvt[-0].return_type_list; } break;
case 209:
# line 863 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-3].token); free(yypvt[-2].token); free(yypvt[-0].token); yyval.return_type_list = yypvt[-1].return_type_list; } break;
case 210:
# line 868 "../../mindy-1.x/comp/parser.y"
{ yyval.return_type_list = make_return_type_list(FALSE, NULL); } break;
case 211:
# line 870 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.return_type_list = make_return_type_list(TRUE, yypvt[-0].expr); } break;
case 212:
# line 872 "../../mindy-1.x/comp/parser.y"
{ yyval.return_type_list = yypvt[-0].return_type_list; } break;
case 213:
# line 874 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-1].token); yyval.return_type_list = set_return_type_rest_type(yypvt[-3].return_type_list, yypvt[-0].expr); } break;
case 214:
# line 879 "../../mindy-1.x/comp/parser.y"
{ yyval.return_type_list = add_return_type(make_return_type_list(FALSE, NULL), yypvt[-0].expr); } break;
case 215:
# line 881 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.return_type_list = add_return_type(yypvt[-2].return_type_list, yypvt[-0].expr); } break;
case 216:
# line 885 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.expr = NULL; } break;
case 217:
# line 886 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-1].token); yyval.expr = yypvt[-0].expr; } break;
case 218:
# line 890 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = make_param_list(); } break;
case 219:
# line 891 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = push_param(yypvt[-1].param, yypvt[-0].param_list); } break;
case 220:
# line 892 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 221:
# line 897 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = make_param_list(); } break;
case 222:
# line 899 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.param_list = push_param(yypvt[-1].param, yypvt[-0].param_list); } break;
case 223:
# line 901 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = yypvt[-0].param_list; } break;
case 224:
# line 906 "../../mindy-1.x/comp/parser.y"
{ yyval.param = make_param(make_id(yypvt[-0].token), NULL); } break;
case 225:
# line 908 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param = make_param(make_id(yypvt[-2].token), yypvt[-0].expr); } break;
case 226:
# line 910 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param = make_param(make_id(yypvt[-2].token), make_singleton(yypvt[-0].expr)); } break;
case 227:
# line 915 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = set_next_param(make_param_list(), yypvt[-0].id); } break;
case 228:
# line 917 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = set_next_param(yypvt[-0].param_list, yypvt[-2].id); } break;
case 229:
# line 919 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 230:
# line 923 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.id = make_id(yypvt[-0].token); } break;
case 231:
# line 928 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = set_rest_param(make_param_list(), yypvt[-0].id); } break;
case 232:
# line 930 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = set_rest_param(yypvt[-0].param_list, yypvt[-2].id); } break;
case 233:
# line 932 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 234:
# line 936 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.id = make_id(yypvt[-0].token); } break;
case 235:
# line 941 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = yypvt[-0].param_list; } break;
case 236:
# line 943 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.param_list = allow_all_keywords(make_param_list()); } break;
case 237:
# line 947 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = allow_keywords(make_param_list()); } break;
case 238:
# line 949 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); free(yypvt[-0].token); yyval.param_list = allow_all_keywords(make_param_list()); } break;
case 239:
# line 950 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = yypvt[-0].param_list; } break;
case 240:
# line 955 "../../mindy-1.x/comp/parser.y"
{ yyval.param_list = push_keyword_param(yypvt[-0].keyword_param, allow_keywords(make_param_list())); } break;
case 241:
# line 957 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); free(yypvt[-0].token);
      yyval.param_list = push_keyword_param(yypvt[-2].keyword_param, allow_all_keywords(make_param_list())); } break;
case 242:
# line 960 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.param_list = push_keyword_param(yypvt[-2].keyword_param, yypvt[-0].param_list); } break;
case 243:
# line 965 "../../mindy-1.x/comp/parser.y"
{ yyval.keyword_param = make_keyword_param(yypvt[-3].token, make_id(yypvt[-2].token), yypvt[-1].expr, yypvt[-0].expr); } break;
case 244:
# line 967 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); free(yypvt[-0].token);
      yyval.keyword_param = make_keyword_param(yypvt[-4].token, make_id(yypvt[-3].token), NULL, yypvt[-1].expr); } break;
case 245:
# line 972 "../../mindy-1.x/comp/parser.y"
{ yyval.token = NULL; } break;
case 246:
# line 973 "../../mindy-1.x/comp/parser.y"
{ yyval.token = yypvt[-0].token; } break;
case 247:
# line 977 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = NULL; } break;
case 248:
# line 978 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = yypvt[-0].expr; } break;
case 249:
# line 982 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = NULL; } break;
case 250:
# line 983 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.expr = yypvt[-0].expr; } break;
case 251:
# line 988 "../../mindy-1.x/comp/parser.y"
{ if (yypvt[-0].token) {
          if (strcasecmp((char *)yypvt[-4].token->chars, (char *)yypvt[-0].token->chars) != 0) {
          error(yypvt[-0].token->line, "mismatched name, ``%s'' isn't ``%s''",
            yypvt[-0].token->chars, yypvt[-4].token->chars);
          yacc_recover();
          }
          free(yypvt[-0].token);
      }
      free(yypvt[-2].token);
      yyval.constituent = (struct constituent *) set_namespace_name(yypvt[-3].defnamespace_constituent, yypvt[-4].token);
    } break;
case 252:
# line 1002 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 253:
# line 1003 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 254:
# line 1006 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = make_define_module(); } break;
case 256:
# line 1008 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = yypvt[-1].defnamespace_constituent; free(yypvt[-0].token); } break;
case 257:
# line 1013 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_use_clause(make_define_module(), yypvt[-0].use_clause); } break;
case 258:
# line 1015 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_exports(make_define_module(), yypvt[-0].variable_names); } break;
case 259:
# line 1017 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_creates(make_define_module(), yypvt[-0].variable_names); } break;
case 260:
# line 1019 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_use_clause(yypvt[-2].defnamespace_constituent, yypvt[-0].use_clause); free(yypvt[-1].token); } break;
case 261:
# line 1021 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_exports(yypvt[-2].defnamespace_constituent, yypvt[-0].variable_names); free(yypvt[-1].token); } break;
case 262:
# line 1023 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_creates(yypvt[-2].defnamespace_constituent, yypvt[-0].variable_names); free(yypvt[-1].token); } break;
case 263:
# line 1027 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.variable_names = yypvt[-0].variable_names; } break;
case 264:
# line 1031 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.variable_names = yypvt[-0].variable_names; } break;
case 265:
# line 1036 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-2].token); yyval.use_clause = make_use_clause(yypvt[-1].token, yypvt[-0].use_options); } break;
case 266:
# line 1040 "../../mindy-1.x/comp/parser.y"
{ yyval.use_options = make_use_options(); } break;
case 267:
# line 1042 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-1].token); yyval.use_options = add_use_option(yypvt[-2].use_options, yypvt[-0].use_option); } break;
case 273:
# line 1055 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_prefix_option(yypvt[-0].token); free(yypvt[-1].token); } break;
case 274:
# line 1060 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_use_option(useopt_IMPORT_ALL); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 275:
# line 1062 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = (struct use_option *) yypvt[-1].import_option; free(yypvt[-3].token); free(yypvt[-2].token); free(yypvt[-0].token); } break;
case 276:
# line 1066 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = make_import_option(); } break;
case 277:
# line 1067 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = yypvt[-0].import_option; } break;
case 278:
# line 1072 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = add_import(make_import_option(), yypvt[-0].token, NULL); } break;
case 279:
# line 1074 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = add_import(make_import_option(), yypvt[-2].token, yypvt[-0].token); free(yypvt[-1].token); } break;
case 280:
# line 1076 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = add_import(yypvt[-2].import_option, yypvt[-0].token, NULL); free(yypvt[-1].token); } break;
case 281:
# line 1078 "../../mindy-1.x/comp/parser.y"
{ yyval.import_option = add_import(yypvt[-4].import_option, yypvt[-2].token, yypvt[-0].token); free(yypvt[-3].token); free(yypvt[-1].token); } break;
case 282:
# line 1083 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_exclude_option(yypvt[-0].variable_names); free(yypvt[-1].token); } break;
case 283:
# line 1088 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_use_option(useopt_EXPORT_ALL); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 284:
# line 1090 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_export_option(yypvt[-0].variable_names); free(yypvt[-1].token); } break;
case 285:
# line 1095 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_rename_option(make_renamings());
      free(yypvt[-2].token); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 286:
# line 1098 "../../mindy-1.x/comp/parser.y"
{ yyval.use_option = make_rename_option(yypvt[-1].renamings); free(yypvt[-3].token); free(yypvt[-2].token); free(yypvt[-0].token); } break;
case 287:
# line 1103 "../../mindy-1.x/comp/parser.y"
{ yyval.renamings = add_renaming(make_renamings(), yypvt[-2].token, yypvt[-0].token); free(yypvt[-1].token); } break;
case 288:
# line 1105 "../../mindy-1.x/comp/parser.y"
{ yyval.renamings = add_renaming(yypvt[-4].renamings, yypvt[-2].token, yypvt[-0].token); free(yypvt[-3].token); free(yypvt[-1].token); } break;
case 289:
# line 1109 "../../mindy-1.x/comp/parser.y"
{ yyval.variable_names = make_variable_names(); free(yypvt[-1].token); free(yypvt[-0].token); } break;
case 290:
# line 1111 "../../mindy-1.x/comp/parser.y"
{ yyval.variable_names = yypvt[-1].variable_names; free(yypvt[-2].token); free(yypvt[-0].token); } break;
case 291:
# line 1115 "../../mindy-1.x/comp/parser.y"
{ yyval.variable_names = add_variable_name(make_variable_names(), yypvt[-0].token); } break;
case 292:
# line 1117 "../../mindy-1.x/comp/parser.y"
{ yyval.variable_names = add_variable_name(yypvt[-2].variable_names, yypvt[-0].token); free(yypvt[-1].token); } break;
case 293:
# line 1122 "../../mindy-1.x/comp/parser.y"
{ if (yypvt[-0].token) {
          if (strcasecmp((char *)yypvt[-4].token->chars, (char *)yypvt[-0].token->chars) != 0) {
          error(yypvt[-0].token->line, "mismatched name, ``%s'' isn't ``%s''",
            yypvt[-0].token->chars, yypvt[-4].token->chars);
          yacc_recover();
          }
          free(yypvt[-0].token);
      }
      free(yypvt[-2].token);
      yyval.constituent = (struct constituent *) set_namespace_name(yypvt[-3].defnamespace_constituent, yypvt[-4].token);
    } break;
case 294:
# line 1136 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 295:
# line 1137 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 296:
# line 1140 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = make_define_library(); } break;
case 298:
# line 1142 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = yypvt[-1].defnamespace_constituent; free(yypvt[-0].token); } break;
case 299:
# line 1147 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_use_clause(make_define_library(), yypvt[-0].use_clause); } break;
case 300:
# line 1149 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_exports(make_define_library(), yypvt[-0].variable_names); } break;
case 301:
# line 1151 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_use_clause(yypvt[-2].defnamespace_constituent, yypvt[-0].use_clause); free(yypvt[-1].token); } break;
case 302:
# line 1153 "../../mindy-1.x/comp/parser.y"
{ yyval.defnamespace_constituent = add_exports(yypvt[-2].defnamespace_constituent, yypvt[-0].variable_names); free(yypvt[-1].token); } break;
case 303:
# line 1157 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 304:
# line 1157 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 305:
# line 1158 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 306:
# line 1158 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 307:
# line 1159 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 308:
# line 1159 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 309:
# line 1160 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 310:
# line 1160 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 311:
# line 1161 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 312:
# line 1161 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 313:
# line 1162 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 314:
# line 1162 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 315:
# line 1163 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 316:
# line 1163 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 317:
# line 1164 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 318:
# line 1164 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 319:
# line 1165 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 320:
# line 1165 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 321:
# line 1166 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 322:
# line 1166 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 323:
# line 1167 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 324:
# line 1167 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 325:
# line 1168 "../../mindy-1.x/comp/parser.y"
{ yyval.nothing = NULL; } break;
case 326:
# line 1168 "../../mindy-1.x/comp/parser.y"
{ free(yypvt[-0].token); yyval.nothing = NULL; } break;
case 327:
# line 1170 "../../mindy-1.x/comp/parser.y"
{ yyval.token = NULL; } break;
case 328:
# line 1170 "../../mindy-1.x/comp/parser.y"
{ yyval.token = yypvt[-0].token; } break;
case 329:
# line 1171 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = NULL; } break;
case 330:
# line 1171 "../../mindy-1.x/comp/parser.y"
{ yyval.expr = yypvt[-0].expr; } break;
case 331:
# line 1172 "../../mindy-1.x/comp/parser.y"
{ yyval.else_part = NULL; } break;
case 332:
# line 1172 "../../mindy-1.x/comp/parser.y"
{ yyval.else_part = yypvt[-0].else_part; } break;
case 333:
# line 1173 "../../mindy-1.x/comp/parser.y"
{ yyval.body = NULL; } break;
case 334:
# line 1173 "../../mindy-1.x/comp/parser.y"
{ yyval.body = yypvt[-0].body; } break;
    }
    goto yystack;        /* reset registers in driver code */
}

# ifdef __RUNTIME_YYMAXDEPTH

static int allocate_stacks() {
    /* allocate the yys and yyv stacks */
    yys = (int *) malloc(yymaxdepth * sizeof(int));
    yyv = (YYSTYPE *) malloc(yymaxdepth * sizeof(YYSTYPE));

    if (yys==0 || yyv==0) {
       yyerror( (nl_msg(30004,"unable to allocate space for yacc stacks")) );
       return(1);
       }
    else return(0);

}


static void free_stacks() {
    if (yys!=0) free((char *) yys);
    if (yyv!=0) free((char *) yyv);
}

# endif  /* defined(__RUNTIME_YYMAXDEPTH) */